diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp
index b61871262b6e3189d868421d32d55215674b37bd..d7d98d0b081e41d84e2423eb3ebcf2a09320adcb 100644
--- a/modules/core/include/opencv2/core/core.hpp
+++ b/modules/core/include/opencv2/core/core.hpp
@@ -90,6 +90,10 @@ class Mat;
 class SparseMat;
 typedef Mat MatND;
 
+namespace gpu {
+    class GpuMat;
+}
+
 class CV_EXPORTS MatExpr;
 class CV_EXPORTS MatOp_Base;
 class CV_EXPORTS MatArg;
@@ -1627,6 +1631,10 @@ public:
     template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
     //! builds matrix from comma initializer
     template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
+
+    //! download data from GpuMat
+    explicit Mat(const gpu::GpuMat& m);
+
     //! destructor - calls release()
     ~Mat();
     //! assignment operators
diff --git a/modules/core/include/opencv2/core/devmem2d.hpp b/modules/core/include/opencv2/core/devmem2d.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ab70c5fe26a9e31d770ddc98d291f689a220caf
--- /dev/null
+++ b/modules/core/include/opencv2/core/devmem2d.hpp
@@ -0,0 +1,157 @@
+/*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 GpuMaterials 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_CORE_DevMem2D_HPP__
+#define __OPENCV_CORE_DevMem2D_HPP__
+
+#ifdef __CUDACC__ 
+    #define __CV_GPU_HOST_DEVICE__ __host__ __device__ __forceinline__ 
+#else
+    #define __CV_GPU_HOST_DEVICE__
+#endif
+
+namespace cv
+{    
+    namespace gpu
+    {
+        // Simple lightweight structures that encapsulates information about an image on device.
+        // It is intended to pass to nvcc-compiled code. GpuMat depends on headers that nvcc can't compile
+
+        template <bool expr> struct StaticAssert;
+        template <> struct StaticAssert<true> {static __CV_GPU_HOST_DEVICE__ void check(){}};        
+
+		template<typename T> struct DevPtr
+		{
+			typedef T elem_type;
+			typedef int index_type;
+
+			enum { elem_size = sizeof(elem_type) };
+
+			T* data;
+
+			__CV_GPU_HOST_DEVICE__ DevPtr() : data(0) {}
+			__CV_GPU_HOST_DEVICE__ DevPtr(T* data_) : data(data_) {}
+
+			__CV_GPU_HOST_DEVICE__ size_t elemSize() const { return elem_size; }
+			__CV_GPU_HOST_DEVICE__ operator       T*()       { return data; }
+			__CV_GPU_HOST_DEVICE__ operator const T*() const { return data; }
+		};
+		
+		template<typename T> struct PtrSz : public DevPtr<T>
+        {                     
+            __CV_GPU_HOST_DEVICE__ PtrSz() : size(0) {}
+            __CV_GPU_HOST_DEVICE__ PtrSz(T* data_, size_t size_) : DevPtr<T>(data_), size(size_) {}
+
+            size_t size;
+        };
+
+		template<typename T> struct PtrStep : public DevPtr<T>
+        {   
+            __CV_GPU_HOST_DEVICE__ PtrStep() : step(0) {}
+			__CV_GPU_HOST_DEVICE__ PtrStep(T* data_, size_t step_) : DevPtr<T>(data_), step(step_) {}
+
+            /** \brief stride between two consecutive rows in bytes. Step is stored always and everywhere in bytes!!! */
+            size_t step;            
+
+			__CV_GPU_HOST_DEVICE__       T* ptr(int y = 0)       { return (      T*)( (      char*)DevPtr<T>::data + y * step); }
+            __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return (const T*)( (const char*)DevPtr<T>::data + y * step); }
+
+			__CV_GPU_HOST_DEVICE__       T& operator ()(int y, int x)       { return ptr(y)[x]; }
+            __CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; }
+        };
+
+		template <typename T> struct PtrStepSz : public PtrStep<T>
+        {   
+            __CV_GPU_HOST_DEVICE__ PtrStepSz() : cols(0), rows(0) {}
+            __CV_GPU_HOST_DEVICE__ PtrStepSz(int rows_, int cols_, T* data_, size_t step_) 
+                : PtrStep<T>(data_, step_), cols(cols_), rows(rows_) {}
+
+            int cols;
+            int rows;                                                                              
+        };
+
+		template <typename T> struct DevMem2D_ : public PtrStepSz<T>
+        {            
+            DevMem2D_() {}
+			DevMem2D_(int rows_, int cols_, T* data_, size_t step_) : PtrStepSz<T>(rows_, cols_, data_, step_) {}
+                            
+            template <typename U>            
+			explicit DevMem2D_(const DevMem2D_<U>& d) : PtrStepSz<T>(d.rows, d.cols, (T*)d.data, d.step) {}                                                                
+        };
+		               
+        template<typename T> struct PtrElemStep_ : public PtrStep<T>
+        {                   
+            PtrElemStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) 
+            {
+                StaticAssert<256 % sizeof(T) == 0>::check();
+
+                PtrStep<T>::step /= PtrStep<T>::elem_size;             
+            }
+            __CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return PtrStep<T>::data + y * PtrStep<T>::step; }
+            __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return PtrStep<T>::data + y * PtrStep<T>::step; }  
+
+            __CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; }
+            __CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; }                  
+        };
+
+		template<typename T> struct PtrStep_ : public PtrStep<T>
+        {            
+            PtrStep_() {}
+            PtrStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) {}                        
+        };
+
+        typedef DevMem2D_<unsigned char> DevMem2Db;
+		typedef DevMem2Db DevMem2D;
+        typedef DevMem2D_<float> DevMem2Df;
+        typedef DevMem2D_<int> DevMem2Di;
+
+        typedef PtrStep<unsigned char> PtrStepb;
+        typedef PtrStep<float> PtrStepf;
+        typedef PtrStep<int> PtrStepi;
+
+        typedef PtrElemStep_<unsigned char> PtrElemStep;
+        typedef PtrElemStep_<float> PtrElemStepf;
+        typedef PtrElemStep_<int> PtrElemStepi;		
+    }    
+}
+
+#endif /* __OPENCV_GPU_DevMem2D_HPP__ */
diff --git a/modules/core/include/opencv2/core/gpumat.hpp b/modules/core/include/opencv2/core/gpumat.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..accfb7c696c28b2db09272e6c1582358095a999d
--- /dev/null
+++ b/modules/core/include/opencv2/core/gpumat.hpp
@@ -0,0 +1,471 @@
+/*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 GpuMaterials 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_GPUMAT_HPP__
+#define __OPENCV_GPUMAT_HPP__
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/devmem2d.hpp"
+
+namespace cv { namespace gpu
+{
+    //! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
+    class CV_EXPORTS GpuMat
+    {
+    public:
+        //! default constructor
+        GpuMat();
+
+        //! constructs GpuMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
+        GpuMat(int rows, int cols, int type);
+        GpuMat(Size size, int type);
+
+        //! constucts GpuMatrix and fills it with the specified value _s.
+        GpuMat(int rows, int cols, int type, Scalar s);
+        GpuMat(Size size, int type, Scalar s);
+
+        //! copy constructor
+        GpuMat(const GpuMat& m);
+
+        //! constructor for GpuMatrix headers pointing to user-allocated data
+        GpuMat(int rows, int cols, int type, void* data, size_t step = Mat::AUTO_STEP);
+        GpuMat(Size size, int type, void* data, size_t step = Mat::AUTO_STEP);
+
+        //! creates a matrix header for a part of the bigger matrix
+        GpuMat(const GpuMat& m, Range rowRange, Range colRange);
+        GpuMat(const GpuMat& m, Rect roi);
+        
+        //! builds GpuMat from Mat. Perfom blocking upload to device.
+        explicit GpuMat(const Mat& m);
+
+        //! destructor - calls release()
+        ~GpuMat();
+
+        //! assignment operators
+        GpuMat& operator = (const GpuMat& m);
+        
+        //! pefroms blocking upload data to GpuMat.
+        void upload(const Mat& m);
+
+        //! downloads data from device to host memory. Blocking calls.
+        void download(Mat& m) const;
+
+        //! returns a new GpuMatrix header for the specified row
+        GpuMat row(int y) const;
+        //! returns a new GpuMatrix header for the specified column
+        GpuMat col(int x) const;
+        //! ... for the specified row span
+        GpuMat rowRange(int startrow, int endrow) const;
+        GpuMat rowRange(Range r) const;
+        //! ... for the specified column span
+        GpuMat colRange(int startcol, int endcol) const;
+        GpuMat colRange(Range r) const;
+
+        //! returns deep copy of the GpuMatrix, i.e. the data is copied
+        GpuMat clone() const;
+        //! copies the GpuMatrix content to "m".
+        // It calls m.create(this->size(), this->type()).
+        void copyTo(GpuMat& m) const;
+        //! copies those GpuMatrix elements to "m" that are marked with non-zero mask elements.
+        void copyTo(GpuMat& m, const GpuMat& mask) const;
+        //! converts GpuMatrix to another datatype with optional scalng. See cvConvertScale.
+        void convertTo(GpuMat& m, int rtype, double alpha = 1, double beta = 0) const;
+
+        void assignTo(GpuMat& m, int type=-1) const;
+
+        //! sets every GpuMatrix element to s
+        GpuMat& operator = (Scalar s);
+        //! sets some of the GpuMatrix elements to s, according to the mask
+        GpuMat& setTo(Scalar s, const GpuMat& mask = GpuMat());
+        //! creates alternative GpuMatrix header for the same data, with different
+        // number of channels and/or different number of rows. see cvReshape.
+        GpuMat reshape(int cn, int rows = 0) const;
+
+        //! allocates new GpuMatrix data unless the GpuMatrix already has specified size and type.
+        // previous data is unreferenced if needed.
+        void create(int rows, int cols, int type);
+        void create(Size size, int type);
+        //! decreases reference counter;
+        // deallocate the data when reference counter reaches 0.
+        void release();
+
+        //! swaps with other smart pointer
+        void swap(GpuMat& mat);
+
+        //! locates GpuMatrix header within a parent GpuMatrix. See below
+        void locateROI(Size& wholeSize, Point& ofs) const;
+        //! moves/resizes the current GpuMatrix ROI inside the parent GpuMatrix.
+        GpuMat& adjustROI(int dtop, int dbottom, int dleft, int dright);
+        //! extracts a rectangular sub-GpuMatrix
+        // (this is a generalized form of row, rowRange etc.)
+        GpuMat operator()(Range rowRange, Range colRange) const;
+        GpuMat operator()(Rect roi) const;
+
+        //! returns true iff the GpuMatrix data is continuous
+        // (i.e. when there are no gaps between successive rows).
+        // similar to CV_IS_GpuMat_CONT(cvGpuMat->type)
+        bool isContinuous() const;
+        //! returns element size in bytes,
+        // similar to CV_ELEM_SIZE(cvMat->type)
+        size_t elemSize() const;
+        //! returns the size of element channel in bytes.
+        size_t elemSize1() const;
+        //! returns element type, similar to CV_MAT_TYPE(cvMat->type)
+        int type() const;
+        //! returns element type, similar to CV_MAT_DEPTH(cvMat->type)
+        int depth() const;
+        //! returns element type, similar to CV_MAT_CN(cvMat->type)
+        int channels() const;
+        //! returns step/elemSize1()
+        size_t step1() const;
+        //! returns GpuMatrix size:
+        // width == number of columns, height == number of rows
+        Size size() const;
+        //! returns true if GpuMatrix data is NULL
+        bool empty() const;
+
+        //! returns pointer to y-th row
+        uchar* ptr(int y = 0);
+        const uchar* ptr(int y = 0) const;
+
+        //! template version of the above method
+        template<typename _Tp> _Tp* ptr(int y = 0);
+        template<typename _Tp> const _Tp* ptr(int y = 0) const;
+
+        template <typename _Tp> operator DevMem2D_<_Tp>() const;
+        template <typename _Tp> operator PtrStep_<_Tp>() const;
+
+        /*! includes several bit-fields:
+        - the magic signature
+        - continuity flag
+        - depth
+        - number of channels
+        */
+        int flags;
+
+        //! the number of rows and columns
+        int rows, cols;
+
+        //! a distance between successive rows in bytes; includes the gap if any
+        size_t step;
+
+        //! pointer to the data
+        uchar* data;
+
+        //! pointer to the reference counter;
+        // when GpuMatrix points to user-allocated data, the pointer is NULL
+        int* refcount;
+
+        //! helper fields used in locateROI and adjustROI
+        uchar* datastart;
+        uchar* dataend;
+    };
+
+    //! Creates continuous GPU matrix
+    CV_EXPORTS void createContinuous(int rows, int cols, int type, GpuMat& m);
+    CV_EXPORTS GpuMat createContinuous(int rows, int cols, int type);
+    CV_EXPORTS void createContinuous(Size size, int type, GpuMat& m);
+    CV_EXPORTS GpuMat createContinuous(Size size, int type);
+
+    //! Ensures that size of the given matrix is not less than (rows, cols) size
+    //! and matrix type is match specified one too
+    CV_EXPORTS void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m);
+    CV_EXPORTS void ensureSizeIsEnough(Size size, int type, GpuMat& m);
+
+    class CV_EXPORTS GpuFuncTable
+    {
+    public:
+        virtual ~GpuFuncTable() {}
+
+        virtual void copy(const Mat& src, GpuMat& dst) const = 0;
+        virtual void copy(const GpuMat& src, Mat& dst) const = 0;
+        virtual void copy(const GpuMat& src, GpuMat& dst) const = 0;
+
+        virtual void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask) const = 0;
+
+        virtual void convert(const GpuMat& src, GpuMat& dst) const = 0;
+        virtual void convert(const GpuMat& src, GpuMat& dst, double alpha, double beta) const = 0;
+
+        virtual void setTo(GpuMat& m, Scalar s, const GpuMat& mask) const = 0;
+
+        virtual void mallocPitch(void** devPtr, size_t* step, size_t width, size_t height) const = 0;
+        virtual void free(void* devPtr) const = 0;
+    };
+
+    CV_EXPORTS void setGpuFuncTable(const GpuFuncTable* funcTbl);
+
+    ////////////////////////////////////////////////////////////////////////
+
+    inline GpuMat::GpuMat() 
+        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) 
+    {
+    }
+
+    inline GpuMat::GpuMat(int rows_, int cols_, int type_) 
+        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+    {
+        if (rows_ > 0 && cols_ > 0)
+            create(rows_, cols_, type_);
+    }
+
+    inline GpuMat::GpuMat(Size size_, int type_) 
+        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+    {
+        if (size_.height > 0 && size_.width > 0)
+            create(size_.height, size_.width, type_);
+    }
+
+    inline GpuMat::GpuMat(int rows_, int cols_, int type_, Scalar s_) 
+        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+    {
+        if (rows_ > 0 && cols_ > 0)
+        {
+            create(rows_, cols_, type_);
+            setTo(s_);
+        }
+    }
+
+    inline GpuMat::GpuMat(Size size_, int type_, Scalar s_) 
+        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+    {
+        if (size_.height > 0 && size_.width > 0)
+        {
+            create(size_.height, size_.width, type_);
+            setTo(s_);
+        }
+    }    
+
+    inline GpuMat::~GpuMat() 
+    { 
+        release(); 
+    }
+
+    inline GpuMat GpuMat::clone() const
+    {
+        GpuMat m;
+        copyTo(m);
+        return m;
+    }
+
+    inline void GpuMat::assignTo(GpuMat& m, int type) const
+    {
+        if (type < 0)
+            m = *this;
+        else
+            convertTo(m, type);
+    }
+
+    inline size_t GpuMat::step1() const 
+    { 
+        return step / elemSize1(); 
+    }
+
+    inline bool GpuMat::empty() const 
+    { 
+        return data == 0; 
+    }
+
+    template<typename _Tp> inline _Tp* GpuMat::ptr(int y)
+    {
+        return (_Tp*)ptr(y);
+    }
+
+    template<typename _Tp> inline const _Tp* GpuMat::ptr(int y) const
+    {
+        return (const _Tp*)ptr(y);
+    }
+
+    inline void swap(GpuMat& a, GpuMat& b) 
+    { 
+        a.swap(b); 
+    }
+
+    inline GpuMat GpuMat::row(int y) const 
+    { 
+        return GpuMat(*this, Range(y, y+1), Range::all()); 
+    }
+
+    inline GpuMat GpuMat::col(int x) const 
+    { 
+        return GpuMat(*this, Range::all(), Range(x, x+1)); 
+    }
+
+    inline GpuMat GpuMat::rowRange(int startrow, int endrow) const 
+    { 
+        return GpuMat(*this, Range(startrow, endrow), Range::all()); 
+    }
+
+    inline GpuMat GpuMat::rowRange(Range r) const 
+    { 
+        return GpuMat(*this, r, Range::all()); 
+    }
+
+    inline GpuMat GpuMat::colRange(int startcol, int endcol) const 
+    { 
+        return GpuMat(*this, Range::all(), Range(startcol, endcol)); 
+    }
+
+    inline GpuMat GpuMat::colRange(Range r) const 
+    { 
+        return GpuMat(*this, Range::all(), r); 
+    }
+
+    inline void GpuMat::create(Size size_, int type_) 
+    { 
+        create(size_.height, size_.width, type_); 
+    }
+
+    inline GpuMat GpuMat::operator()(Range rowRange, Range colRange) const 
+    { 
+        return GpuMat(*this, rowRange, colRange); 
+    }
+
+    inline GpuMat GpuMat::operator()(Rect roi) const 
+    { 
+        return GpuMat(*this, roi); 
+    }
+
+    inline bool GpuMat::isContinuous() const 
+    { 
+        return (flags & Mat::CONTINUOUS_FLAG) != 0; 
+    }
+
+    inline size_t GpuMat::elemSize() const 
+    { 
+        return CV_ELEM_SIZE(flags); 
+    }
+
+    inline size_t GpuMat::elemSize1() const 
+    { 
+        return CV_ELEM_SIZE1(flags); 
+    }
+
+    inline int GpuMat::type() const 
+    { 
+        return CV_MAT_TYPE(flags); 
+    }
+
+    inline int GpuMat::depth() const 
+    { 
+        return CV_MAT_DEPTH(flags); 
+    }
+
+    inline int GpuMat::channels() const 
+    { 
+        return CV_MAT_CN(flags); 
+    }
+
+    inline Size GpuMat::size() const 
+    { 
+        return Size(cols, rows); 
+    }
+
+    inline uchar* GpuMat::ptr(int y)
+    {
+        CV_DbgAssert((unsigned)y < (unsigned)rows);
+        return data + step * y;
+    }
+
+    inline const uchar* GpuMat::ptr(int y) const
+    {
+        CV_DbgAssert((unsigned)y < (unsigned)rows);
+        return data + step * y;
+    }
+
+    inline GpuMat& GpuMat::operator = (Scalar s)
+    {
+        setTo(s);
+        return *this;
+    }
+
+    template <class T> inline GpuMat::operator DevMem2D_<T>() const 
+    { 
+        return DevMem2D_<T>(rows, cols, (T*)data, step); 
+    }
+
+    template <class T> inline GpuMat::operator PtrStep_<T>() const 
+    { 
+        return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this)); 
+    }
+
+    inline GpuMat createContinuous(int rows, int cols, int type)
+    {
+        GpuMat m;
+        createContinuous(rows, cols, type, m);
+        return m;
+    }
+
+    inline void createContinuous(Size size, int type, GpuMat& m)
+    {
+        createContinuous(size.height, size.width, type, m);
+    }
+
+    inline GpuMat createContinuous(Size size, int type)
+    {
+        GpuMat m;
+        createContinuous(size, type, m);
+        return m;
+    }
+
+    inline void ensureSizeIsEnough(Size size, int type, GpuMat& m)
+    {
+        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)
+            m.create(1, area, type);
+        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);
+    }
+}}
+
+#endif // __OPENCV_GPUMAT_HPP__
diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2dffee4c28239da85bfa947ac762c9cda8d5a822
--- /dev/null
+++ b/modules/core/src/gpumat.cpp
@@ -0,0 +1,460 @@
+/*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"
+#include "opencv2/core/gpumat.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+cv::gpu::GpuMat::GpuMat(const GpuMat& m) 
+    : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend)
+{
+    if (refcount)
+        CV_XADD(refcount, 1);
+}
+
+cv::gpu::GpuMat::GpuMat(int rows_, int cols_, int type_, void* data_, size_t step_) : 
+    flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(rows_), cols(cols_), 
+    step(step_), data((uchar*)data_), refcount(0),
+    datastart((uchar*)data_), dataend((uchar*)data_)
+{
+    size_t minstep = cols * elemSize();
+
+    if (step == Mat::AUTO_STEP)
+    {
+        step = minstep;
+        flags |= Mat::CONTINUOUS_FLAG;
+    }
+    else
+    {
+        if (rows == 1) 
+            step = minstep;
+
+        CV_DbgAssert(step >= minstep);
+
+        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
+    }
+    dataend += step * (rows - 1) + minstep;
+}
+
+cv::gpu::GpuMat::GpuMat(Size size_, int type_, void* data_, size_t step_) : 
+    flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(size_.height), cols(size_.width),
+    step(step_), data((uchar*)data_), refcount(0),
+    datastart((uchar*)data_), dataend((uchar*)data_)
+{
+    size_t minstep = cols * elemSize();
+
+    if (step == Mat::AUTO_STEP)
+    {
+        step = minstep;
+        flags |= Mat::CONTINUOUS_FLAG;
+    }
+    else
+    {
+        if (rows == 1) 
+            step = minstep;
+
+        CV_DbgAssert(step >= minstep);
+
+        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
+    }
+    dataend += step * (rows - 1) + minstep;
+}
+
+cv::gpu::GpuMat::GpuMat(const GpuMat& m, Range rowRange, Range colRange)
+{
+    flags = m.flags;
+    step = m.step; refcount = m.refcount;
+    data = m.data; datastart = m.datastart; dataend = m.dataend;
+
+    if (rowRange == Range::all())
+        rows = m.rows;
+    else
+    {
+        CV_Assert(0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows);
+
+        rows = rowRange.size();
+        data += step*rowRange.start;
+    }
+
+    if (colRange == Range::all())
+        cols = m.cols;
+    else
+    {
+        CV_Assert(0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols);
+
+        cols = colRange.size();
+        data += colRange.start*elemSize();
+        flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
+    }
+
+    if (rows == 1)
+        flags |= Mat::CONTINUOUS_FLAG;
+
+    if (refcount)
+        CV_XADD(refcount, 1);
+
+    if (rows <= 0 || cols <= 0)
+        rows = cols = 0;
+}
+
+cv::gpu::GpuMat::GpuMat(const GpuMat& m, Rect roi) : 
+    flags(m.flags), rows(roi.height), cols(roi.width),
+    step(m.step), data(m.data + roi.y*step), refcount(m.refcount),
+    datastart(m.datastart), dataend(m.dataend)
+{
+    flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
+    data += roi.x * elemSize();
+
+    CV_Assert(0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols && 0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows);
+
+    if (refcount)
+        CV_XADD(refcount, 1);
+
+    if (rows <= 0 || cols <= 0)
+        rows = cols = 0;
+}
+
+cv::gpu::GpuMat::GpuMat(const Mat& m) : 
+    flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) 
+{ 
+    upload(m); 
+}
+
+GpuMat& cv::gpu::GpuMat::operator = (const GpuMat& m)
+{
+    if (this != &m)
+    {
+        GpuMat temp(m);
+        swap(temp);
+    }
+
+    return *this;
+}
+
+void cv::gpu::GpuMat::swap(GpuMat& b)
+{
+    std::swap(flags, b.flags);
+    std::swap(rows, b.rows); 
+    std::swap(cols, b.cols);
+    std::swap(step, b.step); 
+    std::swap(data, b.data);
+    std::swap(datastart, b.datastart);
+    std::swap(dataend, b.dataend);
+    std::swap(refcount, b.refcount);
+}
+
+void cv::gpu::GpuMat::locateROI(Size& wholeSize, Point& ofs) const
+{
+    size_t esz = elemSize();
+    ptrdiff_t delta1 = data - datastart;
+    ptrdiff_t delta2 = dataend - datastart;
+
+    CV_DbgAssert(step > 0);
+
+    if (delta1 == 0)
+        ofs.x = ofs.y = 0;
+    else
+    {
+        ofs.y = static_cast<int>(delta1 / step);
+        ofs.x = static_cast<int>((delta1 - step * ofs.y) / esz);
+
+        CV_DbgAssert(data == datastart + ofs.y * step + ofs.x * esz);
+    }
+
+    size_t minstep = (ofs.x + cols) * esz;
+
+    wholeSize.height = std::max(static_cast<int>((delta2 - minstep) / step + 1), ofs.y + rows);
+    wholeSize.width = std::max(static_cast<int>((delta2 - step * (wholeSize.height - 1)) / esz), ofs.x + cols);
+}
+
+GpuMat& cv::gpu::GpuMat::adjustROI(int dtop, int dbottom, int dleft, int dright)
+{
+    Size wholeSize; 
+    Point ofs;
+    locateROI(wholeSize, ofs);
+
+    size_t esz = elemSize();
+
+    int row1 = std::max(ofs.y - dtop, 0); 
+    int row2 = std::min(ofs.y + rows + dbottom, wholeSize.height);
+
+    int col1 = std::max(ofs.x - dleft, 0);
+    int col2 = std::min(ofs.x + cols + dright, wholeSize.width);
+
+    data += (row1 - ofs.y) * step + (col1 - ofs.x) * esz;
+    rows = row2 - row1; 
+    cols = col2 - col1;
+
+    if (esz * cols == step || rows == 1)
+        flags |= Mat::CONTINUOUS_FLAG;
+    else
+        flags &= ~Mat::CONTINUOUS_FLAG;
+
+    return *this;
+}
+
+GpuMat cv::gpu::GpuMat::reshape(int new_cn, int new_rows) const
+{
+    GpuMat hdr = *this;
+
+    int cn = channels();
+    if (new_cn == 0)
+        new_cn = cn;
+
+    int total_width = cols * cn;
+
+    if ((new_cn > total_width || total_width % new_cn != 0) && new_rows == 0)
+        new_rows = rows * total_width / new_cn;
+
+    if (new_rows != 0 && new_rows != rows)
+    {
+        int total_size = total_width * rows;
+
+        if (!isContinuous())
+            CV_Error(CV_BadStep, "The matrix is not continuous, thus its number of rows can not be changed");
+
+        if ((unsigned)new_rows > (unsigned)total_size)
+            CV_Error(CV_StsOutOfRange, "Bad new number of rows");
+
+        total_width = total_size / new_rows;
+
+        if (total_width * new_rows != total_size)
+            CV_Error(CV_StsBadArg, "The total number of matrix elements is not divisible by the new number of rows");
+
+        hdr.rows = new_rows;
+        hdr.step = total_width * elemSize1();
+    }
+
+    int new_width = total_width / new_cn;
+
+    if (new_width * new_cn != total_width)
+        CV_Error(CV_BadNumChannels, "The total width is not divisible by the new number of channels");
+
+    hdr.cols = new_width;
+    hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn - 1) << CV_CN_SHIFT);
+
+    return hdr;
+}
+
+cv::Mat::Mat(const GpuMat& m) : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0), datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
+{
+    m.download(*this);
+}
+
+namespace
+{
+    void throw_nogpu() 
+    { 
+        CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); 
+    }
+
+    class EmptyFuncTable : public GpuFuncTable
+    {
+    public:
+        void copy(const Mat&, GpuMat&) const { throw_nogpu(); }
+        void copy(const GpuMat&, Mat&) const { throw_nogpu(); }
+        void copy(const GpuMat&, GpuMat&) const { throw_nogpu(); }
+
+        void copyWithMask(const GpuMat&, GpuMat&, const GpuMat&) const { throw_nogpu(); }
+
+        void convert(const GpuMat&, GpuMat&) const { throw_nogpu(); }
+        void convert(const GpuMat&, GpuMat&, double, double) const { throw_nogpu(); }
+
+        void setTo(GpuMat&, Scalar, const GpuMat&) const { throw_nogpu(); }
+
+        void mallocPitch(void**, size_t*, size_t, size_t) const { throw_nogpu(); }
+        void free(void*) const {}
+    };
+
+    const GpuFuncTable* g_funcTbl = 0;
+
+    const GpuFuncTable* gpuFuncTable()
+    {
+        static EmptyFuncTable empty;
+        return g_funcTbl ? g_funcTbl : &empty;
+    }
+}
+
+void cv::gpu::setGpuFuncTable(const GpuFuncTable* funcTbl)
+{
+    g_funcTbl = funcTbl;
+}
+
+void cv::gpu::GpuMat::upload(const Mat& m)
+{
+    CV_DbgAssert(!m.empty());
+
+    create(m.size(), m.type());
+
+    gpuFuncTable()->copy(m, *this);
+}
+
+void cv::gpu::GpuMat::download(Mat& m) const
+{
+    CV_DbgAssert(!empty());
+
+    m.create(size(), type());
+
+    gpuFuncTable()->copy(*this, m);
+}
+
+void cv::gpu::GpuMat::copyTo(GpuMat& m) const
+{
+    CV_DbgAssert(!empty());
+
+    m.create(size(), type());
+
+    gpuFuncTable()->copy(*this, m);
+}
+
+void cv::gpu::GpuMat::copyTo(GpuMat& mat, const GpuMat& mask) const
+{
+    if (mask.empty())
+        copyTo(mat);
+    else
+    {
+        mat.create(size(), type());
+
+        gpuFuncTable()->copyWithMask(*this, mat, mask);
+    }
+}
+
+void cv::gpu::GpuMat::convertTo(GpuMat& dst, int rtype, double alpha, double beta) const
+{
+    bool noScale = fabs(alpha - 1) < numeric_limits<double>::epsilon() && fabs(beta) < numeric_limits<double>::epsilon();
+
+    if (rtype < 0)
+        rtype = type();
+    else
+        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), channels());
+
+    int sdepth = depth();
+    int ddepth = CV_MAT_DEPTH(rtype);
+    if (sdepth == ddepth && noScale)
+    {
+        copyTo(dst);
+        return;
+    }
+
+    GpuMat temp;
+    const GpuMat* psrc = this;
+    if (sdepth != ddepth && psrc == &dst)
+    {
+        temp = *this;
+        psrc = &temp;
+    }
+
+    dst.create(size(), rtype);
+
+    if (noScale)
+        gpuFuncTable()->convert(*psrc, dst);
+    else
+        gpuFuncTable()->convert(*psrc, dst, alpha, beta);
+}
+
+GpuMat& cv::gpu::GpuMat::setTo(Scalar s, const GpuMat& mask)
+{
+    CV_Assert(mask.empty() || mask.type() == CV_8UC1);
+    CV_DbgAssert(!empty());
+
+    gpuFuncTable()->setTo(*this, s, mask);    
+
+    return *this;
+}
+
+void cv::gpu::GpuMat::create(int _rows, int _cols, int _type)
+{
+    _type &= TYPE_MASK;
+
+    if (rows == _rows && cols == _cols && type() == _type && data)
+        return;
+
+    if (data)
+        release();
+
+    CV_DbgAssert(_rows >= 0 && _cols >= 0);
+
+    if (_rows > 0 && _cols > 0)
+    {
+        flags = Mat::MAGIC_VAL + _type;
+        rows = _rows;
+        cols = _cols;
+
+        size_t esz = elemSize();
+
+        void* devPtr;
+        gpuFuncTable()->mallocPitch(&devPtr, &step, esz * cols, rows);
+
+        // Single row must be continuous
+        if (rows == 1)
+            step = esz * cols;
+
+        if (esz * cols == step)
+            flags |= Mat::CONTINUOUS_FLAG;
+
+        int64 _nettosize = static_cast<int64>(step) * rows;
+        size_t nettosize = static_cast<size_t>(_nettosize);
+
+        datastart = data = static_cast<uchar*>(devPtr);
+        dataend = data + nettosize;
+
+        refcount = static_cast<int*>(fastMalloc(sizeof(*refcount)));
+        *refcount = 1;
+    }
+}
+
+void cv::gpu::GpuMat::release()
+{
+    if (refcount && CV_XADD(refcount, -1) == 1)
+    {
+        fastFree(refcount);
+
+        gpuFuncTable()->free(datastart);
+    }
+
+    data = datastart = dataend = 0;
+    step = rows = cols = 0;
+    refcount = 0;
+}
diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 74ccc320e396e482adc9c413de40a707499e87d0..fcef9b9f629a75f90c3e3086e0f88270cc8c65ff 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -3,7 +3,8 @@ set(name "gpu")
 set(the_target "opencv_${name}")
 project(${the_target})
 
-set(DEPS "opencv_core" "opencv_imgproc" "opencv_objdetect" "opencv_features2d" "opencv_flann" "opencv_calib3d") #"opencv_features2d" "opencv_flann" "opencv_objdetect" - only headers needed 
+set(DEPS "opencv_core" "opencv_imgproc" "opencv_calib3d" "opencv_objdetect")
+set(DEPS_HEADER ${DEPS} "opencv_features2d" "opencv_flann")
 set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} opencv_gpu)
 
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
@@ -27,6 +28,13 @@ file(GLOB lib_device_hdrs_detail "src/opencv2/gpu/device/detail/*.h*")
 source_group("Device" FILES ${lib_device_hdrs})
 source_group("Device\\Detail" FILES ${lib_device_hdrs_detail})
 
+foreach(d ${DEPS_HEADER})
+	if(${d} MATCHES "opencv_")
+		string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
+		include_directories("${d_dir}/include")
+	endif()
+endforeach()
+
 if (HAVE_CUDA)
     file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp")	
     file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")
@@ -50,7 +58,6 @@ if (HAVE_CUDA)
     if (APPLE)
         set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;-fno-finite-math-only;")
     endif()
-    
 
     string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
     string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
@@ -60,7 +67,7 @@ if (HAVE_CUDA)
         #string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
         #string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
         #string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4211 /wd4201 /wd4100 /wd4505 /wd4408")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4211 /wd4201 /wd4100 /wd4505 /wd4408 /wd4251")
 
         string(REPLACE "/EHsc-" "/EHs" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
         string(REPLACE "/EHsc-" "/EHs" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
@@ -69,22 +76,19 @@ if (HAVE_CUDA)
         string(REPLACE "/EHsc-" "/EHs" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
         string(REPLACE "/EHsc-" "/EHs" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
     endif()
-	
+
     if (BUILD_SHARED_LIBS)
-		set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;-DCVAPI_EXPORTS")
-	endif()
+        set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;-DCVAPI_EXPORTS")
+    endif()
     
+    if(MSVC)
+        set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/wd4251")
+    endif()
+
     CUDA_COMPILE(cuda_objs ${lib_cuda} ${ncv_cuda})
     #CUDA_BUILD_CLEAN_TARGET()
 endif()
 
-foreach(d ${DEPS})
-	if(${d} MATCHES "opencv_")
-		string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
-		include_directories("${d_dir}/include")
-	endif()
-endforeach()
-
 add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${lib_device_hdrs} ${lib_device_hdrs_detail} ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda} ${cuda_objs})
 
 # For dynamic link numbering convenions
diff --git a/modules/gpu/include/opencv2/gpu/devmem2d.hpp b/modules/gpu/include/opencv2/gpu/devmem2d.hpp
index e454f000c8d5d5975c38f19fd33b806183b96302..33af66afa1d2ec9c906b1cb85b3214eaa102bb38 100644
--- a/modules/gpu/include/opencv2/gpu/devmem2d.hpp
+++ b/modules/gpu/include/opencv2/gpu/devmem2d.hpp
@@ -40,122 +40,4 @@
 //
 //M*/
 
-#ifndef __OPENCV_GPU_DevMem2D_HPP__
-#define __OPENCV_GPU_DevMem2D_HPP__
-
-
-namespace cv
-{    
-    namespace gpu
-    {
-        // Simple lightweight structures that encapsulates information about an image on device.
-        // It is intended to pass to nvcc-compiled code. GpuMat depends on headers that nvcc can't compile
-
-#if defined(__CUDACC__) 
-    #define __CV_GPU_HOST_DEVICE__ __host__ __device__ __forceinline__ 
-#else
-    #define __CV_GPU_HOST_DEVICE__
-#endif
-
-        template <bool expr> struct StaticAssert;
-        template <> struct StaticAssert<true> {static __CV_GPU_HOST_DEVICE__ void check(){}};        
-
-		template<typename T> struct DevPtr
-		{
-			typedef T elem_type;
-			typedef int index_type;
-
-			enum { elem_size = sizeof(elem_type) };
-
-			T* data;
-
-			__CV_GPU_HOST_DEVICE__ DevPtr() : data(0) {}
-			__CV_GPU_HOST_DEVICE__ DevPtr(T* data_) : data(data_) {}
-
-			__CV_GPU_HOST_DEVICE__ size_t elemSize() const { return elem_size; }
-			__CV_GPU_HOST_DEVICE__ operator       T*()       { return data; }
-			__CV_GPU_HOST_DEVICE__ operator const T*() const { return data; }
-		};
-		
-		template<typename T> struct PtrSz : public DevPtr<T>
-        {                     
-            __CV_GPU_HOST_DEVICE__ PtrSz() : size(0) {}
-            __CV_GPU_HOST_DEVICE__ PtrSz(T* data_, size_t size_) : DevPtr<T>(data_), size(size_) {}
-
-            size_t size;
-        };
-
-		template<typename T> struct PtrStep : public DevPtr<T>
-        {   
-            __CV_GPU_HOST_DEVICE__ PtrStep() : step(0) {}
-			__CV_GPU_HOST_DEVICE__ PtrStep(T* data_, size_t step_) : DevPtr<T>(data_), step(step_) {}
-
-            /** \brief stride between two consecutive rows in bytes. Step is stored always and everywhere in bytes!!! */
-            size_t step;            
-
-			__CV_GPU_HOST_DEVICE__       T* ptr(int y = 0)       { return (      T*)( (      char*)DevPtr<T>::data + y * step); }
-            __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return (const T*)( (const char*)DevPtr<T>::data + y * step); }
-
-			__CV_GPU_HOST_DEVICE__       T& operator ()(int y, int x)       { return ptr(y)[x]; }
-            __CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; }
-        };
-
-		template <typename T> struct PtrStepSz : public PtrStep<T>
-        {   
-            __CV_GPU_HOST_DEVICE__ PtrStepSz() : cols(0), rows(0) {}
-            __CV_GPU_HOST_DEVICE__ PtrStepSz(int rows_, int cols_, T* data_, size_t step_) 
-                : PtrStep<T>(data_, step_), cols(cols_), rows(rows_) {}
-
-            int cols;
-            int rows;                                                                              
-        };
-
-		template <typename T> struct DevMem2D_ : public PtrStepSz<T>
-        {            
-            DevMem2D_() {}
-			DevMem2D_(int rows_, int cols_, T *data_, size_t step_) : PtrStepSz<T>(rows_, cols_, data_, step_) {}
-                            
-            template <typename U>            
-			explicit DevMem2D_(const DevMem2D_<U>& d) : PtrStepSz<T>(d.rows, d.cols, (T*)d.data, d.step) {}                                                                
-        };
-		               
-        template<typename T> struct PtrElemStep_ : public PtrStep<T>
-        {                   
-            PtrElemStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) 
-            {
-                StaticAssert<256 % sizeof(T) == 0>::check();
-
-                PtrStep<T>::step /= PtrStep<T>::elem_size;             
-            }
-            __CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return PtrStep<T>::data + y * PtrStep<T>::step; }
-            __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return PtrStep<T>::data + y * PtrStep<T>::step; }  
-
-            __CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; }
-            __CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; }                  
-        };
-
-		template<typename T> struct PtrStep_ : public PtrStep<T>
-        {            
-            PtrStep_() {}
-            PtrStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) {}                        
-        };
-
-#undef __CV_GPU_HOST_DEVICE__
-
-
-        typedef DevMem2D_<unsigned char> DevMem2Db;
-		typedef DevMem2Db DevMem2D;
-        typedef DevMem2D_<float> DevMem2Df;
-        typedef DevMem2D_<int> DevMem2Di;
-
-        typedef PtrStep<unsigned char> PtrStepb;
-        typedef PtrStep<float> PtrStepf;
-        typedef PtrStep<int> PtrStepi;
-
-        typedef PtrElemStep_<unsigned char> PtrElemStep;
-        typedef PtrElemStep_<float> PtrElemStepf;
-        typedef PtrElemStep_<int> PtrElemStepi;		
-    }    
-}
-
-#endif /* __OPENCV_GPU_DevMem2D_HPP__ */
+#include "opencv2/core/devmem2d.hpp"
diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 38f6a955b90ce109bfe329281f4c494db029a483..ffa32fbe371f73481ce757543ebf9a1e45d0194a 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -43,1520 +43,1530 @@
 #ifndef __OPENCV_GPU_HPP__
 #define __OPENCV_GPU_HPP__
 
+#ifndef SKIP_INCLUDES
 #include <vector>
-#include "opencv2/core/core.hpp"
+#endif
+
+#include "opencv2/core/gpumat.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/objdetect/objdetect.hpp"
 #include "opencv2/features2d/features2d.hpp"
-#include "opencv2/gpu/gpumat.hpp"
 
-namespace cv
-{
-    namespace gpu
-    {
-        //////////////////////////////// Initialization & Info ////////////////////////
-
-        //! This is the only function that do not throw exceptions if the library is compiled without Cuda.
-        CV_EXPORTS int getCudaEnabledDeviceCount();
-
-        //! Functions below throw cv::Expception if the library is compiled without Cuda.
-
-        CV_EXPORTS void setDevice(int device);
-        CV_EXPORTS int getDevice();
-
-        //! Explicitly destroys and cleans up all resources associated with the current device in the current process. 
-        //! Any subsequent API call to this device will reinitialize the device.
-        CV_EXPORTS void resetDevice();
-
-        enum FeatureSet
-        {
-            FEATURE_SET_COMPUTE_10 = 10,
-            FEATURE_SET_COMPUTE_11 = 11,
-            FEATURE_SET_COMPUTE_12 = 12,
-            FEATURE_SET_COMPUTE_13 = 13,
-            FEATURE_SET_COMPUTE_20 = 20,
-            FEATURE_SET_COMPUTE_21 = 21,
-            GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
-            SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
-            NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13
-        };
+namespace cv { namespace gpu {
 
-        // Gives information about what GPU archs this OpenCV GPU module was 
-        // compiled for
-        class CV_EXPORTS TargetArchs
-        {
-        public:
-            static bool builtWith(FeatureSet feature_set);
-            static bool has(int major, int minor);
-            static bool hasPtx(int major, int minor);
-            static bool hasBin(int major, int minor);
-            static bool hasEqualOrLessPtx(int major, int minor);
-            static bool hasEqualOrGreater(int major, int minor);
-            static bool hasEqualOrGreaterPtx(int major, int minor);
-            static bool hasEqualOrGreaterBin(int major, int minor);
-        private:
-            TargetArchs();
-        };
+//////////////////////////////// Initialization & Info ////////////////////////
 
-        // Gives information about the given GPU
-        class CV_EXPORTS DeviceInfo
-        {
-        public:
-            // Creates DeviceInfo object for the current GPU
-            DeviceInfo() : device_id_(getDevice()) { query(); }
+//! This is the only function that do not throw exceptions if the library is compiled without Cuda.
+CV_EXPORTS int getCudaEnabledDeviceCount();
 
-            // Creates DeviceInfo object for the given GPU
-            DeviceInfo(int device_id) : device_id_(device_id) { query(); }
+//! Functions below throw cv::Expception if the library is compiled without Cuda.
 
-            string name() const { return name_; }
-
-            // Return compute capability versions
-            int majorVersion() const { return majorVersion_; }
-            int minorVersion() const { return minorVersion_; }
+CV_EXPORTS void setDevice(int device);
+CV_EXPORTS int getDevice();
 
-            int multiProcessorCount() const { return multi_processor_count_; }
+//! Explicitly destroys and cleans up all resources associated with the current device in the current process. 
+//! Any subsequent API call to this device will reinitialize the device.
+CV_EXPORTS void resetDevice();
 
-            size_t freeMemory() const;
-            size_t totalMemory() const;
+enum FeatureSet
+{
+    FEATURE_SET_COMPUTE_10 = 10,
+    FEATURE_SET_COMPUTE_11 = 11,
+    FEATURE_SET_COMPUTE_12 = 12,
+    FEATURE_SET_COMPUTE_13 = 13,
+    FEATURE_SET_COMPUTE_20 = 20,
+    FEATURE_SET_COMPUTE_21 = 21,
+    GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
+    SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
+    NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13
+};
+
+// Gives information about what GPU archs this OpenCV GPU module was 
+// compiled for
+class CV_EXPORTS TargetArchs
+{
+public:
+    static bool builtWith(FeatureSet feature_set);
+    static bool has(int major, int minor);
+    static bool hasPtx(int major, int minor);
+    static bool hasBin(int major, int minor);
+    static bool hasEqualOrLessPtx(int major, int minor);
+    static bool hasEqualOrGreater(int major, int minor);
+    static bool hasEqualOrGreaterPtx(int major, int minor);
+    static bool hasEqualOrGreaterBin(int major, int minor);
+private:
+    TargetArchs();
+};
+
+// Gives information about the given GPU
+class CV_EXPORTS DeviceInfo
+{
+public:
+    // Creates DeviceInfo object for the current GPU
+    DeviceInfo() : device_id_(getDevice()) { query(); }
 
-            // Checks whether device supports the given feature
-            bool supports(FeatureSet feature_set) const;
+    // Creates DeviceInfo object for the given GPU
+    DeviceInfo(int device_id) : device_id_(device_id) { query(); }
 
-            // Checks whether the GPU module can be run on the given device
-            bool isCompatible() const;
+    std::string name() const { return name_; }
 
-            int deviceID() const { return device_id_; }
+    // Return compute capability versions
+    int majorVersion() const { return majorVersion_; }
+    int minorVersion() const { return minorVersion_; }
 
-        private:
-            void query();
-            void queryMemory(size_t& free_memory, size_t& total_memory) const;
+    int multiProcessorCount() const { return multi_processor_count_; }
 
-            int device_id_;
+    size_t freeMemory() const;
+    size_t totalMemory() const;
 
-            string name_;
-            int multi_processor_count_;
-            int majorVersion_;
-            int minorVersion_;
-        };
+    // Checks whether device supports the given feature
+    bool supports(FeatureSet feature_set) const;
 
-        //////////////////////////////// Error handling ////////////////////////
+    // Checks whether the GPU module can be run on the given device
+    bool isCompatible() const;
 
-        CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func);
+    int deviceID() const { return device_id_; }
 
-        //////////////////////////////// CudaMem ////////////////////////////////
-        // CudaMem is limited cv::Mat with page locked memory allocation.
-        // Page locked memory is only needed for async and faster coping to GPU.
-        // It is convertable to cv::Mat header without reference counting
-        // so you can use it with other opencv functions.
+private:
+    void query();
+    void queryMemory(size_t& free_memory, size_t& total_memory) const;
 
-        // Page-locks the matrix m memory and maps it for the device(s)
-        CV_EXPORTS void registerPageLocked(Mat& m);
-        // Unmaps the memory of matrix m, and makes it pageable again.
-        CV_EXPORTS void unregisterPageLocked(Mat& m);
+    int device_id_;
 
-        class CV_EXPORTS CudaMem
-        {
-        public:
-            enum  { ALLOC_PAGE_LOCKED = 1, ALLOC_ZEROCOPY = 2, ALLOC_WRITE_COMBINED = 4 };
+    std::string name_;
+    int multi_processor_count_;
+    int majorVersion_;
+    int minorVersion_;
+};
 
-            CudaMem();
-            CudaMem(const CudaMem& m);
+//////////////////////////////// Error handling ////////////////////////
 
-            CudaMem(int rows, int cols, int type, int _alloc_type = ALLOC_PAGE_LOCKED);
-            CudaMem(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED);
+CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func);
 
+//////////////////////////////// CudaMem ////////////////////////////////
+// CudaMem is limited cv::Mat with page locked memory allocation.
+// Page locked memory is only needed for async and faster coping to GPU.
+// It is convertable to cv::Mat header without reference counting
+// so you can use it with other opencv functions.
 
-            //! creates from cv::Mat with coping data
-            explicit CudaMem(const Mat& m, int alloc_type = ALLOC_PAGE_LOCKED);
+// Page-locks the matrix m memory and maps it for the device(s)
+CV_EXPORTS void registerPageLocked(Mat& m);
+// Unmaps the memory of matrix m, and makes it pageable again.
+CV_EXPORTS void unregisterPageLocked(Mat& m);
 
-            ~CudaMem();
+class CV_EXPORTS CudaMem
+{
+public:
+    enum  { ALLOC_PAGE_LOCKED = 1, ALLOC_ZEROCOPY = 2, ALLOC_WRITE_COMBINED = 4 };
 
-            CudaMem& operator = (const CudaMem& m);
+    CudaMem();
+    CudaMem(const CudaMem& m);
 
-            //! returns deep copy of the matrix, i.e. the data is copied
-            CudaMem clone() const;
+    CudaMem(int rows, int cols, int type, int _alloc_type = ALLOC_PAGE_LOCKED);
+    CudaMem(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED);
 
-            //! allocates new matrix data unless the matrix already has specified size and type.
-            void create(int rows, int cols, int type, int alloc_type = ALLOC_PAGE_LOCKED);
-            void create(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED);
 
-            //! decrements reference counter and released memory if needed.
-            void release();
+    //! creates from cv::Mat with coping data
+    explicit CudaMem(const Mat& m, int alloc_type = ALLOC_PAGE_LOCKED);
 
-            //! returns matrix header with disabled reference counting for CudaMem data.
-            Mat createMatHeader() const;
-            operator Mat() const;
+    ~CudaMem();
 
-            //! maps host memory into device address space and returns GpuMat header for it. Throws exception if not supported by hardware.
-            GpuMat createGpuMatHeader() const;
-            operator GpuMat() const;
+    CudaMem& operator = (const CudaMem& m);
 
-            //returns if host memory can be mapperd to gpu address space;
-            static bool canMapHostMemory();
+    //! returns deep copy of the matrix, i.e. the data is copied
+    CudaMem clone() const;
 
-            // Please see cv::Mat for descriptions
-            bool isContinuous() const;
-            size_t elemSize() const;
-            size_t elemSize1() const;
-            int type() const;
-            int depth() const;
-            int channels() const;
-            size_t step1() const;
-            Size size() const;
-            bool empty() const;
+    //! allocates new matrix data unless the matrix already has specified size and type.
+    void create(int rows, int cols, int type, int alloc_type = ALLOC_PAGE_LOCKED);
+    void create(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED);
 
+    //! decrements reference counter and released memory if needed.
+    void release();
 
-            // Please see cv::Mat for descriptions
-            int flags;
-            int rows, cols;
-            size_t step;
+    //! returns matrix header with disabled reference counting for CudaMem data.
+    Mat createMatHeader() const;
+    operator Mat() const;
 
-            uchar* data;
-            int* refcount;
+    //! maps host memory into device address space and returns GpuMat header for it. Throws exception if not supported by hardware.
+    GpuMat createGpuMatHeader() const;
+    operator GpuMat() const;
 
-            uchar* datastart;
-            uchar* dataend;
+    //returns if host memory can be mapperd to gpu address space;
+    static bool canMapHostMemory();
 
-            int alloc_type;
-        };
+    // Please see cv::Mat for descriptions
+    bool isContinuous() const;
+    size_t elemSize() const;
+    size_t elemSize1() const;
+    int type() const;
+    int depth() const;
+    int channels() const;
+    size_t step1() const;
+    Size size() const;
+    bool empty() const;
 
-        //////////////////////////////// CudaStream ////////////////////////////////
-        // Encapculates Cuda Stream. Provides interface for async coping.
-        // Passed to each function that supports async kernel execution.
-        // Reference counting is enabled
 
-        class CV_EXPORTS Stream
-        {
-        public:
-            Stream();
-            ~Stream();
+    // Please see cv::Mat for descriptions
+    int flags;
+    int rows, cols;
+    size_t step;
+
+    uchar* data;
+    int* refcount;
+
+    uchar* datastart;
+    uchar* dataend;
+
+    int alloc_type;
+};
+
+//////////////////////////////// CudaStream ////////////////////////////////
+// Encapculates Cuda Stream. Provides interface for async coping.
+// Passed to each function that supports async kernel execution.
+// Reference counting is enabled
+
+class CV_EXPORTS Stream
+{
+public:
+    Stream();
+    ~Stream();
 
-            Stream(const Stream&);
-            Stream& operator=(const Stream&);
+    Stream(const Stream&);
+    Stream& operator=(const Stream&);
 
-            bool queryIfComplete();
-            void waitForCompletion();
+    bool queryIfComplete();
+    void waitForCompletion();
 
-            //! downloads asynchronously.
-            // Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its subMat)
-            void enqueueDownload(const GpuMat& src, CudaMem& dst);
-            void enqueueDownload(const GpuMat& src, Mat& dst);
+    //! downloads asynchronously.
+    // Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its subMat)
+    void enqueueDownload(const GpuMat& src, CudaMem& dst);
+    void enqueueDownload(const GpuMat& src, Mat& dst);
 
-            //! uploads asynchronously.
-            // Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its ROI)
-            void enqueueUpload(const CudaMem& src, GpuMat& dst);
-            void enqueueUpload(const Mat& src, GpuMat& dst);
+    //! uploads asynchronously.
+    // Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its ROI)
+    void enqueueUpload(const CudaMem& src, GpuMat& dst);
+    void enqueueUpload(const Mat& src, GpuMat& dst);
 
-            void enqueueCopy(const GpuMat& src, GpuMat& dst);
+    void enqueueCopy(const GpuMat& src, GpuMat& dst);
 
-            void enqueueMemSet(GpuMat& src, Scalar val);
-            void enqueueMemSet(GpuMat& src, Scalar val, const GpuMat& mask);
+    void enqueueMemSet(GpuMat& src, Scalar val);
+    void enqueueMemSet(GpuMat& src, Scalar val, const GpuMat& mask);
 
-            // converts matrix type, ex from float to uchar depending on type
-            void enqueueConvert(const GpuMat& src, GpuMat& dst, int type, double a = 1, double b = 0);
+    // converts matrix type, ex from float to uchar depending on type
+    void enqueueConvert(const GpuMat& src, GpuMat& dst, int type, double a = 1, double b = 0);
 
-            static Stream& Null();
+    static Stream& Null();
 
-            operator bool() const;
+    operator bool() const;
 
-        private:
-            void create();
-            void release();
+private:
+    void create();
+    void release();
 
-            struct Impl;
-            Impl *impl;
+    struct Impl;
+    Impl *impl;
 
-            friend struct StreamAccessor;
-            
-            explicit Stream(Impl* impl);
-        };
+    friend struct StreamAccessor;
+    
+    explicit Stream(Impl* impl);
+};
         
 
-        //////////////////////////////// Filter Engine ////////////////////////////////
-
-        /*!
-        The Base Class for 1D or Row-wise Filters
-
-        This is the base class for linear or non-linear filters that process 1D data.
-        In particular, such filters are used for the "horizontal" filtering parts in separable filters.
-        */
-        class CV_EXPORTS BaseRowFilter_GPU
-        {
-        public:
-            BaseRowFilter_GPU(int ksize_, int anchor_) : ksize(ksize_), anchor(anchor_) {}
-            virtual ~BaseRowFilter_GPU() {}
-            virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
-            int ksize, anchor;
-        };
-
-        /*!
-        The Base Class for Column-wise Filters
-
-        This is the base class for linear or non-linear filters that process columns of 2D arrays.
-        Such filters are used for the "vertical" filtering parts in separable filters.
-        */
-        class CV_EXPORTS BaseColumnFilter_GPU
-        {
-        public:
-            BaseColumnFilter_GPU(int ksize_, int anchor_) : ksize(ksize_), anchor(anchor_) {}
-            virtual ~BaseColumnFilter_GPU() {}
-            virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
-            int ksize, anchor;
-        };
-
-        /*!
-        The Base Class for Non-Separable 2D Filters.
-
-        This is the base class for linear or non-linear 2D filters.
-        */
-        class CV_EXPORTS BaseFilter_GPU
-        {
-        public:
-            BaseFilter_GPU(const Size& ksize_, const Point& anchor_) : ksize(ksize_), anchor(anchor_) {}
-            virtual ~BaseFilter_GPU() {}
-            virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
-            Size ksize;
-            Point anchor;
-        };
-
-        /*!
-        The Base Class for Filter Engine.
-
-        The class can be used to apply an arbitrary filtering operation to an image.
-        It contains all the necessary intermediate buffers.
-        */
-        class CV_EXPORTS FilterEngine_GPU
-        {
-        public:
-            virtual ~FilterEngine_GPU() {}
-
-            virtual void apply(const GpuMat& src, GpuMat& dst, Rect roi = Rect(0,0,-1,-1), Stream& stream = Stream::Null()) = 0;
-        };
-
-        //! returns the non-separable filter engine with the specified filter
-        CV_EXPORTS Ptr<FilterEngine_GPU> createFilter2D_GPU(const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType);
-
-        //! returns the separable filter engine with the specified filters
-        CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU>& rowFilter,
-            const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType);
-        CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU>& rowFilter,
-            const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType, GpuMat& buf);
-
-        //! returns horizontal 1D box filter
-        //! supports only CV_8UC1 source type and CV_32FC1 sum type
-        CV_EXPORTS Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1);
-
-        //! returns vertical 1D box filter
-        //! supports only CV_8UC1 sum type and CV_32FC1 dst type
-        CV_EXPORTS Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1);
-
-        //! returns 2D box filter
-        //! supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type
-        CV_EXPORTS Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1));
-
-        //! returns box filter engine
-        CV_EXPORTS Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size& ksize,
-            const Point& anchor = Point(-1,-1));
-
-        //! returns 2D morphological filter
-        //! only MORPH_ERODE and MORPH_DILATE are supported
-        //! supports CV_8UC1 and CV_8UC4 types
-        //! kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
-        CV_EXPORTS Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize,
-            Point anchor=Point(-1,-1));
-
-        //! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
-        CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat& kernel,
-            const Point& anchor = Point(-1,-1), int iterations = 1);
-        CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat& kernel, GpuMat& buf,
-            const Point& anchor = Point(-1,-1), int iterations = 1);
-
-        //! returns 2D filter with the specified kernel
-        //! supports CV_8UC1 and CV_8UC4 types
-        CV_EXPORTS Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize,
-            Point anchor = Point(-1, -1));
-
-        //! returns the non-separable linear filter engine
-        CV_EXPORTS Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel,
-            const Point& anchor = Point(-1,-1));
-
-        //! returns the primitive row filter with the specified kernel.
-        //! supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 source type.
-        //! there are two version of algorithm: NPP and OpenCV.
-        //! NPP calls when srcType == CV_8UC1 or srcType == CV_8UC4 and bufType == srcType,
-        //! otherwise calls OpenCV version.
-        //! NPP supports only BORDER_CONSTANT border type.
-        //! OpenCV version supports only CV_32F as buffer depth and
-        //! BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.
-        CV_EXPORTS Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel,
-            int anchor = -1, int borderType = BORDER_DEFAULT);
-
-        //! returns the primitive column filter with the specified kernel.
-        //! supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 dst type.
-        //! there are two version of algorithm: NPP and OpenCV.
-        //! NPP calls when dstType == CV_8UC1 or dstType == CV_8UC4 and bufType == dstType,
-        //! otherwise calls OpenCV version.
-        //! NPP supports only BORDER_CONSTANT border type.
-        //! OpenCV version supports only CV_32F as buffer depth and
-        //! BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.
-        CV_EXPORTS Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel,
-            int anchor = -1, int borderType = BORDER_DEFAULT);
-
-        //! returns the separable linear filter engine
-        CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel,
-            const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT,
-            int columnBorderType = -1);
-        CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel,
-            const Mat& columnKernel, GpuMat& buf, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT,
-            int columnBorderType = -1);
-
-        //! returns filter engine for the generalized Sobel operator
-        CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-        CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, GpuMat& buf,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-
-        //! returns the Gaussian filter engine
-        CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigma1, double sigma2 = 0,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-        CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, GpuMat& buf, double sigma1, double sigma2 = 0,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-
-        //! returns maximum filter
-        CV_EXPORTS Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1));
-
-        //! returns minimum filter
-        CV_EXPORTS Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1));
-
-        //! smooths the image using the normalized box filter
-        //! supports CV_8UC1, CV_8UC4 types
-        CV_EXPORTS void boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), Stream& stream = Stream::Null());
-
-        //! a synonym for normalized box filter
-        static inline void blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1), Stream& stream = Stream::Null()) { boxFilter(src, dst, -1, ksize, anchor, stream); }
-
-        //! erodes the image (applies the local minimum operator)
-        CV_EXPORTS void erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
-        CV_EXPORTS void erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, GpuMat& buf, Point anchor = Point(-1, -1), int iterations = 1, Stream& stream = Stream::Null());
-
-        //! dilates the image (applies the local maximum operator)
-        CV_EXPORTS void dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
-        CV_EXPORTS void dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, GpuMat& buf, Point anchor = Point(-1, -1), int iterations = 1, Stream& stream = Stream::Null());
-
-        //! applies an advanced morphological operation to the image
-        CV_EXPORTS void morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
-        CV_EXPORTS void morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, GpuMat& buf1, GpuMat& buf2, Point anchor = Point(-1, -1), int iterations = 1, Stream& stream = Stream::Null());
-
-        //! applies non-separable 2D linear filter to the image
-        CV_EXPORTS void filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1), Stream& stream = Stream::Null());
-
-        //! applies separable 2D linear filter to the image
-        CV_EXPORTS void sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY,
-            Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-        CV_EXPORTS void sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, GpuMat& buf,
-            Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
-
-        //! applies generalized Sobel operator to the image
-        CV_EXPORTS void Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-        CV_EXPORTS void Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, int ksize = 3, double scale = 1,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
-
-        //! applies the vertical or horizontal Scharr operator to the image
-        CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-        CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, double scale = 1,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
-
-        //! smooths the image using Gaussian filter.
-        CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigma1, double sigma2 = 0,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
-        CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, GpuMat& buf, double sigma1, double sigma2 = 0,
-            int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
-
-        //! applies Laplacian operator to the image
-        //! supports only ksize = 1 and ksize = 3
-        CV_EXPORTS void Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1, Stream& stream = Stream::Null());
-
-
-        ////////////////////////////// Arithmetics ///////////////////////////////////
-
-        //! implements generalized matrix product algorithm GEMM from BLAS
-        CV_EXPORTS void gemm(const GpuMat& src1, const GpuMat& src2, double alpha, 
-            const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null());
-
-        //! transposes the matrix
-        //! supports matrix with element size = 1, 4 and 8 bytes (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc)
-        CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! reverses the order of the rows, columns or both in a matrix
-        //! supports CV_8UC1, CV_8UC4 types
-        CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode, Stream& stream = Stream::Null());
-
-        //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
-        //! destination array will have the depth type as lut and the same channels number as source
-        //! supports CV_8UC1, CV_8UC3 types
-        CV_EXPORTS void LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! makes multi-channel array out of several single-channel arrays
-        CV_EXPORTS void merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! makes multi-channel array out of several single-channel arrays
-        CV_EXPORTS void merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! copies each plane of a multi-channel array to a dedicated array
-        CV_EXPORTS void split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null());
-
-        //! copies each plane of a multi-channel array to a dedicated array
-        CV_EXPORTS void split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null());
-
-        //! computes magnitude of complex (x(i).re, x(i).im) vector
-        //! supports only CV_32FC2 type
-        CV_EXPORTS void magnitude(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes squared magnitude of complex (x(i).re, x(i).im) vector
-        //! supports only CV_32FC2 type
-        CV_EXPORTS void magnitudeSqr(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes magnitude of each (x(i), y(i)) vector
-        //! supports only floating-point source
-        CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes squared magnitude of each (x(i), y(i)) vector
-        //! supports only floating-point source
-        CV_EXPORTS void magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes angle (angle(i)) of each (x(i), y(i)) vector
-        //! supports only floating-point source
-        CV_EXPORTS void phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
-
-        //! converts Cartesian coordinates to polar
-        //! supports only floating-point source
-        CV_EXPORTS void cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
-
-        //! converts polar coordinates to Cartesian
-        //! supports only floating-point source
-        CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees = false, Stream& stream = Stream::Null());
+//////////////////////////////// Filter Engine ////////////////////////////////
 
+/*!
+The Base Class for 1D or Row-wise Filters
 
-        //////////////////////////// Per-element operations ////////////////////////////////////
-
-        //! adds one matrix to another (c = a + b)
-        CV_EXPORTS void add(const GpuMat& a, const GpuMat& b, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
-        //! adds scalar to a matrix (c = a + s)
-        CV_EXPORTS void add(const GpuMat& a, const Scalar& sc, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
-
-        //! subtracts one matrix from another (c = a - b)
-        CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
-        //! subtracts scalar from a matrix (c = a - s)
-        CV_EXPORTS void subtract(const GpuMat& a, const Scalar& sc, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
-
-        //! computes element-wise weighted product of the two arrays (c = scale * a * b)
-        CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
-        //! weighted multiplies matrix to a scalar (c = scale * a * s)
-        CV_EXPORTS void multiply(const GpuMat& a, const Scalar& sc, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
+This is the base class for linear or non-linear filters that process 1D data.
+In particular, such filters are used for the "horizontal" filtering parts in separable filters.
+*/
+class CV_EXPORTS BaseRowFilter_GPU
+{
+public:
+    BaseRowFilter_GPU(int ksize_, int anchor_) : ksize(ksize_), anchor(anchor_) {}
+    virtual ~BaseRowFilter_GPU() {}
+    virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
+    int ksize, anchor;
+};
+
+/*!
+The Base Class for Column-wise Filters
+
+This is the base class for linear or non-linear filters that process columns of 2D arrays.
+Such filters are used for the "vertical" filtering parts in separable filters.
+*/
+class CV_EXPORTS BaseColumnFilter_GPU
+{
+public:
+    BaseColumnFilter_GPU(int ksize_, int anchor_) : ksize(ksize_), anchor(anchor_) {}
+    virtual ~BaseColumnFilter_GPU() {}
+    virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
+    int ksize, anchor;
+};
+
+/*!
+The Base Class for Non-Separable 2D Filters.
+
+This is the base class for linear or non-linear 2D filters.
+*/
+class CV_EXPORTS BaseFilter_GPU
+{
+public:
+    BaseFilter_GPU(const Size& ksize_, const Point& anchor_) : ksize(ksize_), anchor(anchor_) {}
+    virtual ~BaseFilter_GPU() {}
+    virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
+    Size ksize;
+    Point anchor;
+};
+
+/*!
+The Base Class for Filter Engine.
+
+The class can be used to apply an arbitrary filtering operation to an image.
+It contains all the necessary intermediate buffers.
+*/
+class CV_EXPORTS FilterEngine_GPU
+{
+public:
+    virtual ~FilterEngine_GPU() {}
+
+    virtual void apply(const GpuMat& src, GpuMat& dst, Rect roi = Rect(0,0,-1,-1), Stream& stream = Stream::Null()) = 0;
+};
+
+//! returns the non-separable filter engine with the specified filter
+CV_EXPORTS Ptr<FilterEngine_GPU> createFilter2D_GPU(const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType);
+
+//! returns the separable filter engine with the specified filters
+CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU>& rowFilter,
+    const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType);
+CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU>& rowFilter,
+    const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType, GpuMat& buf);
+
+//! returns horizontal 1D box filter
+//! supports only CV_8UC1 source type and CV_32FC1 sum type
+CV_EXPORTS Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1);
+
+//! returns vertical 1D box filter
+//! supports only CV_8UC1 sum type and CV_32FC1 dst type
+CV_EXPORTS Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1);
+
+//! returns 2D box filter
+//! supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type
+CV_EXPORTS Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1));
+
+//! returns box filter engine
+CV_EXPORTS Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size& ksize,
+    const Point& anchor = Point(-1,-1));
+
+//! returns 2D morphological filter
+//! only MORPH_ERODE and MORPH_DILATE are supported
+//! supports CV_8UC1 and CV_8UC4 types
+//! kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
+CV_EXPORTS Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize,
+    Point anchor=Point(-1,-1));
+
+//! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
+CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat& kernel,
+    const Point& anchor = Point(-1,-1), int iterations = 1);
+CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat& kernel, GpuMat& buf,
+    const Point& anchor = Point(-1,-1), int iterations = 1);
+
+//! returns 2D filter with the specified kernel
+//! supports CV_8UC1 and CV_8UC4 types
+CV_EXPORTS Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize,
+    Point anchor = Point(-1, -1));
+
+//! returns the non-separable linear filter engine
+CV_EXPORTS Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel,
+    const Point& anchor = Point(-1,-1));
+
+//! returns the primitive row filter with the specified kernel.
+//! supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 source type.
+//! there are two version of algorithm: NPP and OpenCV.
+//! NPP calls when srcType == CV_8UC1 or srcType == CV_8UC4 and bufType == srcType,
+//! otherwise calls OpenCV version.
+//! NPP supports only BORDER_CONSTANT border type.
+//! OpenCV version supports only CV_32F as buffer depth and
+//! BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.
+CV_EXPORTS Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel,
+    int anchor = -1, int borderType = BORDER_DEFAULT);
+
+//! returns the primitive column filter with the specified kernel.
+//! supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 dst type.
+//! there are two version of algorithm: NPP and OpenCV.
+//! NPP calls when dstType == CV_8UC1 or dstType == CV_8UC4 and bufType == dstType,
+//! otherwise calls OpenCV version.
+//! NPP supports only BORDER_CONSTANT border type.
+//! OpenCV version supports only CV_32F as buffer depth and
+//! BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.
+CV_EXPORTS Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel,
+    int anchor = -1, int borderType = BORDER_DEFAULT);
+
+//! returns the separable linear filter engine
+CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel,
+    const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT,
+    int columnBorderType = -1);
+CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel,
+    const Mat& columnKernel, GpuMat& buf, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT,
+    int columnBorderType = -1);
+
+//! returns filter engine for the generalized Sobel operator
+CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize,
+                                                       int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, GpuMat& buf,
+                                                       int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+
+//! returns the Gaussian filter engine
+CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigma1, double sigma2 = 0,
+                                                          int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, GpuMat& buf, double sigma1, double sigma2 = 0,
+                                                          int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+
+//! returns maximum filter
+CV_EXPORTS Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1));
+
+//! returns minimum filter
+CV_EXPORTS Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1));
+
+//! smooths the image using the normalized box filter
+//! supports CV_8UC1, CV_8UC4 types
+CV_EXPORTS void boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), Stream& stream = Stream::Null());
+
+//! a synonym for normalized box filter
+static inline void blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1), Stream& stream = Stream::Null()) 
+{ 
+    boxFilter(src, dst, -1, ksize, anchor, stream); 
+}
 
-        //! computes element-wise weighted quotient of the two arrays (c = a / b)
-        CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
-        //! computes element-wise weighted quotient of matrix and scalar (c = a / s)
-        CV_EXPORTS void divide(const GpuMat& a, const Scalar& sc, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
-        //! computes element-wise weighted reciprocal of an array (dst = scale/src2)
-        CV_EXPORTS void divide(double scale, const GpuMat& src2, GpuMat& dst, int dtype = -1, Stream& stream = Stream::Null());
+//! erodes the image (applies the local minimum operator)
+CV_EXPORTS void erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
+CV_EXPORTS void erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, GpuMat& buf, 
+                      Point anchor = Point(-1, -1), int iterations = 1, 
+                      Stream& stream = Stream::Null());
 
-        //! computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
-        CV_EXPORTS void addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2, double beta, double gamma, GpuMat& dst, 
-            int dtype = -1, Stream& stream = Stream::Null());
+//! dilates the image (applies the local maximum operator)
+CV_EXPORTS void dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
+CV_EXPORTS void dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, GpuMat& buf, 
+                       Point anchor = Point(-1, -1), int iterations = 1, 
+                       Stream& stream = Stream::Null());
 
-        //! adds scaled array to another one (dst = alpha*src1 + src2)
-        static inline void scaleAdd(const GpuMat& src1, double alpha, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null())
-        {
-            addWeighted(src1, alpha, src2, 1.0, 0.0, dst, -1, stream);
-        }
+//! applies an advanced morphological operation to the image
+CV_EXPORTS void morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
+CV_EXPORTS void morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, GpuMat& buf1, GpuMat& buf2, 
+                             Point anchor = Point(-1, -1), int iterations = 1, Stream& stream = Stream::Null());
 
-        //! computes element-wise absolute difference of two arrays (c = abs(a - b))
-        CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
-        //! computes element-wise absolute difference of array and scalar (c = abs(a - s))
-        CV_EXPORTS void absdiff(const GpuMat& a, const Scalar& s, GpuMat& c, Stream& stream = Stream::Null());
+//! applies non-separable 2D linear filter to the image
+CV_EXPORTS void filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1), Stream& stream = Stream::Null());
 
-        //! computes exponent of each matrix element (b = e**a)
-        //! supports only CV_32FC1 type
-        CV_EXPORTS void exp(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
-        
-        //! computes power of each matrix element:
-        //    (dst(i,j) = pow(     src(i,j) , power), if src.type() is integer
-        //    (dst(i,j) = pow(fabs(src(i,j)), power), otherwise
-        //! supports all, except depth == CV_64F
-        CV_EXPORTS void pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream = Stream::Null());
+//! applies separable 2D linear filter to the image
+CV_EXPORTS void sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY,
+                            Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+CV_EXPORTS void sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, GpuMat& buf,
+                            Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, 
+                            Stream& stream = Stream::Null());
+
+//! applies generalized Sobel operator to the image
+CV_EXPORTS void Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1,
+                      int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+CV_EXPORTS void Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, int ksize = 3, double scale = 1,
+                      int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
+
+//! applies the vertical or horizontal Scharr operator to the image
+CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1,
+                       int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, double scale = 1,
+                       int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
+
+//! smooths the image using Gaussian filter.
+CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigma1, double sigma2 = 0,
+                             int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
+CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, GpuMat& buf, double sigma1, double sigma2 = 0,
+                             int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
+
+//! applies Laplacian operator to the image
+//! supports only ksize = 1 and ksize = 3
+CV_EXPORTS void Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1, Stream& stream = Stream::Null());
+
+
+////////////////////////////// Arithmetics ///////////////////////////////////
+
+//! implements generalized matrix product algorithm GEMM from BLAS
+CV_EXPORTS void gemm(const GpuMat& src1, const GpuMat& src2, double alpha, 
+    const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null());
+
+//! transposes the matrix
+//! supports matrix with element size = 1, 4 and 8 bytes (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc)
+CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst, Stream& stream = Stream::Null());
+
+//! reverses the order of the rows, columns or both in a matrix
+//! supports CV_8UC1, CV_8UC4 types
+CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode, Stream& stream = Stream::Null());
+
+//! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
+//! destination array will have the depth type as lut and the same channels number as source
+//! supports CV_8UC1, CV_8UC3 types
+CV_EXPORTS void LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null());
+
+//! makes multi-channel array out of several single-channel arrays
+CV_EXPORTS void merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null());
+
+//! makes multi-channel array out of several single-channel arrays
+CV_EXPORTS void merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());
+
+//! copies each plane of a multi-channel array to a dedicated array
+CV_EXPORTS void split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null());
+
+//! copies each plane of a multi-channel array to a dedicated array
+CV_EXPORTS void split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null());
+
+//! computes magnitude of complex (x(i).re, x(i).im) vector
+//! supports only CV_32FC2 type
+CV_EXPORTS void magnitude(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+//! computes squared magnitude of complex (x(i).re, x(i).im) vector
+//! supports only CV_32FC2 type
+CV_EXPORTS void magnitudeSqr(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+//! computes magnitude of each (x(i), y(i)) vector
+//! supports only floating-point source
+CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+//! computes squared magnitude of each (x(i), y(i)) vector
+//! supports only floating-point source
+CV_EXPORTS void magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+//! computes angle (angle(i)) of each (x(i), y(i)) vector
+//! supports only floating-point source
+CV_EXPORTS void phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
+
+//! converts Cartesian coordinates to polar
+//! supports only floating-point source
+CV_EXPORTS void cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
+
+//! converts polar coordinates to Cartesian
+//! supports only floating-point source
+CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees = false, Stream& stream = Stream::Null());
 
-        //! computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
-        //! supports only CV_32FC1 type
-        CV_EXPORTS void log(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
 
-        //! compares elements of two arrays (c = a <cmpop> b)
-        //! supports CV_8UC4, CV_32FC1 types
-        CV_EXPORTS void compare(const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
+//////////////////////////// Per-element operations ////////////////////////////////////
 
-        //! performs per-elements bit-wise inversion
-        CV_EXPORTS void bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+//! adds one matrix to another (c = a + b)
+CV_EXPORTS void add(const GpuMat& a, const GpuMat& b, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
+//! adds scalar to a matrix (c = a + s)
+CV_EXPORTS void add(const GpuMat& a, const Scalar& sc, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
 
-        //! calculates per-element bit-wise disjunction of two arrays
-        CV_EXPORTS void bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+//! subtracts one matrix from another (c = a - b)
+CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
+//! subtracts scalar from a matrix (c = a - s)
+CV_EXPORTS void subtract(const GpuMat& a, const Scalar& sc, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
 
-        //! calculates per-element bit-wise conjunction of two arrays
-        CV_EXPORTS void bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+//! computes element-wise weighted product of the two arrays (c = scale * a * b)
+CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
+//! weighted multiplies matrix to a scalar (c = scale * a * s)
+CV_EXPORTS void multiply(const GpuMat& a, const Scalar& sc, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
 
-        //! calculates per-element bit-wise "exclusive or" operation
-        CV_EXPORTS void bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+//! computes element-wise weighted quotient of the two arrays (c = a / b)
+CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
+//! computes element-wise weighted quotient of matrix and scalar (c = a / s)
+CV_EXPORTS void divide(const GpuMat& a, const Scalar& sc, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
+//! computes element-wise weighted reciprocal of an array (dst = scale/src2)
+CV_EXPORTS void divide(double scale, const GpuMat& src2, GpuMat& dst, int dtype = -1, Stream& stream = Stream::Null());
 
-        //! computes per-element minimum of two arrays (dst = min(src1, src2))
-        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
+//! computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
+CV_EXPORTS void addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2, double beta, double gamma, GpuMat& dst, 
+                            int dtype = -1, Stream& stream = Stream::Null());
 
-        //! computes per-element minimum of array and scalar (dst = min(src1, src2))
-        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
+//! adds scaled array to another one (dst = alpha*src1 + src2)
+static inline void scaleAdd(const GpuMat& src1, double alpha, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null())
+{
+    addWeighted(src1, alpha, src2, 1.0, 0.0, dst, -1, stream);
+}
 
-        //! computes per-element maximum of two arrays (dst = max(src1, src2))
-        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
+//! computes element-wise absolute difference of two arrays (c = abs(a - b))
+CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
+//! computes element-wise absolute difference of array and scalar (c = abs(a - s))
+CV_EXPORTS void absdiff(const GpuMat& a, const Scalar& s, GpuMat& c, Stream& stream = Stream::Null());
 
-        //! computes per-element maximum of array and scalar (dst = max(src1, src2))
-        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
+//! computes exponent of each matrix element (b = e**a)
+//! supports only CV_32FC1 type
+CV_EXPORTS void exp(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
 
+//! computes power of each matrix element:
+//    (dst(i,j) = pow(     src(i,j) , power), if src.type() is integer
+//    (dst(i,j) = pow(fabs(src(i,j)), power), otherwise
+//! supports all, except depth == CV_64F
+CV_EXPORTS void pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream = Stream::Null());
 
-        ////////////////////////////// Image processing //////////////////////////////
+//! computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
+//! supports only CV_32FC1 type
+CV_EXPORTS void log(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
 
-        //! DST[x,y] = SRC[xmap[x,y],ymap[x,y]]
-        //! supports only CV_32FC1 map type
-        CV_EXPORTS void remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap,
-            int interpolation, int borderMode = BORDER_CONSTANT, const Scalar& borderValue = Scalar(), 
-            Stream& stream = Stream::Null());
+//! compares elements of two arrays (c = a <cmpop> b)
+//! supports CV_8UC4, CV_32FC1 types
+CV_EXPORTS void compare(const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
 
-        //! Does mean shift filtering on GPU.
-        CV_EXPORTS void meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
-            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1), Stream& stream = Stream::Null());
+//! performs per-elements bit-wise inversion
+CV_EXPORTS void bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
 
-        //! Does mean shift procedure on GPU.
-        CV_EXPORTS void meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr,
-            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1), Stream& stream = Stream::Null());
+//! calculates per-element bit-wise disjunction of two arrays
+CV_EXPORTS void bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
 
-        //! Does mean shift segmentation with elimination of small regions.
-        CV_EXPORTS void meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize,
-            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
+//! calculates per-element bit-wise conjunction of two arrays
+CV_EXPORTS void bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
 
-        //! Does coloring of disparity image: [0..ndisp) -> [0..240, 1, 1] in HSV.
-        //! Supported types of input disparity: CV_8U, CV_16S.
-        //! Output disparity has CV_8UC4 type in BGRA format (alpha = 255).
-        CV_EXPORTS void drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, Stream& stream = Stream::Null());
-
-        //! Reprojects disparity image to 3D space.
-        //! Supports CV_8U and CV_16S types of input disparity.
-        //! The output is a 4-channel floating-point (CV_32FC4) matrix.
-        //! Each element of this matrix will contain the 3D coordinates of the point (x,y,z,1), computed from the disparity map.
-        //! Q is the 4x4 perspective transformation matrix that can be obtained with cvStereoRectify.
-        CV_EXPORTS void reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, Stream& stream = Stream::Null());
-
-        //! converts image from one color space to another
-        CV_EXPORTS void cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0, Stream& stream = Stream::Null());
-
-        //! applies fixed threshold to the image
-        CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
-
-        //! resizes the image
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! warps the image using affine transformation
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        CV_EXPORTS void warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! warps the image using perspective transformation
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        CV_EXPORTS void warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! builds plane warping maps
-        CV_EXPORTS void buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, const Mat &T, float scale,
-                                           GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
-
-        //! builds cylindrical warping maps
-        CV_EXPORTS void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
-                                                 GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
-
-        //! builds spherical warping maps
-        CV_EXPORTS void buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
-                                               GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
-
-        //! rotate 8bit single or four channel image
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        //! supports CV_8UC1, CV_8UC4 types
-        CV_EXPORTS void rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, 
-            int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! copies 2D array to a larger destination array and pads borders with user-specifiable constant
-        CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType, 
-            const Scalar& value = Scalar(), Stream& stream = Stream::Null());
-
-        //! computes the integral image
-        //! sum will have CV_32S type, but will contain unsigned int values
-        //! supports only CV_8UC1 source type
-        CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, Stream& stream = Stream::Null());
-
-        //! buffered version
-        CV_EXPORTS void integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, Stream& stream = Stream::Null());
-
-        //! computes the integral image and integral for the squared image
-        //! sum will have CV_32S type, sqsum - CV32F type
-        //! supports only CV_8UC1 source type
-        CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum, Stream& stream = Stream::Null());
-
-        //! computes squared integral image
-        //! result matrix will have 64F type, but will contain 64U values
-        //! supports source images of 8UC1 type only
-        CV_EXPORTS void sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& stream = Stream::Null());
-
-        //! computes vertical sum, supports only CV_32FC1 images
-        CV_EXPORTS void columnSum(const GpuMat& src, GpuMat& sum);
-
-        //! computes the standard deviation of integral images
-        //! supports only CV_32SC1 source type and CV_32FC1 sqr type
-        //! output will have CV_32FC1 type
-        CV_EXPORTS void rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& stream = Stream::Null());
-
-        //! computes Harris cornerness criteria at each image pixel
-        CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, 
-            int borderType = BORDER_REFLECT101);
-        CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, double k, 
-            int borderType = BORDER_REFLECT101);
-        CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, double k, 
-            int borderType = BORDER_REFLECT101, Stream& stream = Stream::Null());
-
-        //! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
-        CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
-        CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
-        CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, 
-            int borderType=BORDER_REFLECT101, Stream& stream = Stream::Null());
-
-        //! performs per-element multiplication of two full (not packed) Fourier spectrums
-        //! supports 32FC2 matrixes only (interleaved format)
-        CV_EXPORTS void mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false, Stream& stream = Stream::Null());
-
-        //! performs per-element multiplication of two full (not packed) Fourier spectrums
-        //! supports 32FC2 matrixes only (interleaved format)
-        CV_EXPORTS void mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false, Stream& stream = Stream::Null());
-
-        //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
-        //! Param dft_size is the size of DFT transform.
-        //! 
-        //! If the source matrix is not continous, then additional copy will be done,
-        //! so to avoid copying ensure the source matrix is continous one. If you want to use
-        //! preallocated output ensure it is continuous too, otherwise it will be reallocated.
-        //!
-        //! Being implemented via CUFFT real-to-complex transform result contains only non-redundant values
-        //! in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.
-        //!
-        //! For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.
-        CV_EXPORTS void dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0, Stream& stream = Stream::Null());
-
-        //! computes convolution (or cross-correlation) of two images using discrete Fourier transform
-        //! supports source images of 32FC1 type only
-        //! result matrix will have 32FC1 type
-        struct CV_EXPORTS ConvolveBuf;
-        CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr = false);
-        CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream = Stream::Null());
-
-        struct CV_EXPORTS ConvolveBuf
-        {
-            ConvolveBuf() {}
-            ConvolveBuf(Size image_size, Size templ_size) 
-                { create(image_size, templ_size); }
-            void create(Size image_size, Size templ_size);
-            void create(Size image_size, Size templ_size, Size block_size);
-
-        private:
-            static Size estimateBlockSize(Size result_size, Size templ_size);
-            friend void convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&, Stream& stream);
-
-            Size result_size;
-            Size block_size;
-            Size dft_size;
-            int spect_len;
-
-            GpuMat image_spect, templ_spect, result_spect;
-            GpuMat image_block, templ_block, result_data;
-        };
-
-        //! computes the proximity map for the raster template and the image where the template is searched for
-        CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, Stream& stream = Stream::Null());
-
-        //! smoothes the source image and downsamples it
-        CV_EXPORTS void pyrDown(const GpuMat& src, GpuMat& dst, int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null());
-
-        //! upsamples the source image and then smoothes it
-        CV_EXPORTS void pyrUp(const GpuMat& src, GpuMat& dst, int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null());
-
-        //! performs linear blending of two images
-        //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
-        CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
-            GpuMat& result, Stream& stream = Stream::Null());
+//! calculates per-element bit-wise "exclusive or" operation
+CV_EXPORTS void bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
 
-        
-        struct CV_EXPORTS CannyBuf;
-        
-        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);
+//! computes per-element minimum of two arrays (dst = min(src1, src2))
+CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
 
-        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_);
+//! computes per-element minimum of array and scalar (dst = min(src1, src2))
+CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
 
-            void create(const Size& image_size, int apperture_size = 3);
-            
-            void release();
+//! computes per-element maximum of two arrays (dst = max(src1, src2))
+CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
 
-            GpuMat dx, dy;
-            GpuMat dx_buf, dy_buf;
-            GpuMat edgeBuf;
-            GpuMat trackBuf1, trackBuf2;
-            Ptr<FilterEngine_GPU> filterDX, filterDY;
-        };
+//! computes per-element maximum of array and scalar (dst = max(src1, src2))
+CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
+
+
+////////////////////////////// Image processing //////////////////////////////
+
+//! DST[x,y] = SRC[xmap[x,y],ymap[x,y]]
+//! supports only CV_32FC1 map type
+CV_EXPORTS void remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap,
+                      int interpolation, int borderMode = BORDER_CONSTANT, const Scalar& borderValue = Scalar(), 
+                      Stream& stream = Stream::Null());
+
+//! Does mean shift filtering on GPU.
+CV_EXPORTS void meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
+                                   TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1), 
+                                   Stream& stream = Stream::Null());
+
+//! Does mean shift procedure on GPU.
+CV_EXPORTS void meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr,
+                              TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1), 
+                              Stream& stream = Stream::Null());
+
+//! Does mean shift segmentation with elimination of small regions.
+CV_EXPORTS void meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize,
+                                      TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
+
+//! Does coloring of disparity image: [0..ndisp) -> [0..240, 1, 1] in HSV.
+//! Supported types of input disparity: CV_8U, CV_16S.
+//! Output disparity has CV_8UC4 type in BGRA format (alpha = 255).
+CV_EXPORTS void drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, Stream& stream = Stream::Null());
+
+//! Reprojects disparity image to 3D space.
+//! Supports CV_8U and CV_16S types of input disparity.
+//! The output is a 4-channel floating-point (CV_32FC4) matrix.
+//! Each element of this matrix will contain the 3D coordinates of the point (x,y,z,1), computed from the disparity map.
+//! Q is the 4x4 perspective transformation matrix that can be obtained with cvStereoRectify.
+CV_EXPORTS void reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, Stream& stream = Stream::Null());
+
+//! converts image from one color space to another
+CV_EXPORTS void cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0, Stream& stream = Stream::Null());
+
+//! applies fixed threshold to the image
+CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
+
+//! resizes the image
+//! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
+
+//! warps the image using affine transformation
+//! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+CV_EXPORTS void warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
+
+//! warps the image using perspective transformation
+//! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+CV_EXPORTS void warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
+
+//! builds plane warping maps
+CV_EXPORTS void buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, const Mat &T, float scale,
+                                   GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
+
+//! builds cylindrical warping maps
+CV_EXPORTS void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
+                                         GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
+
+//! builds spherical warping maps
+CV_EXPORTS void buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
+                                       GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
+
+//! rotate 8bit single or four channel image
+//! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+//! supports CV_8UC1, CV_8UC4 types
+CV_EXPORTS void rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, 
+                       int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
+
+//! copies 2D array to a larger destination array and pads borders with user-specifiable constant
+CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType, 
+                               const Scalar& value = Scalar(), Stream& stream = Stream::Null());
+
+//! computes the integral image
+//! sum will have CV_32S type, but will contain unsigned int values
+//! supports only CV_8UC1 source type
+CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, Stream& stream = Stream::Null());
+
+//! buffered version
+CV_EXPORTS void integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, Stream& stream = Stream::Null());
+
+//! computes the integral image and integral for the squared image
+//! sum will have CV_32S type, sqsum - CV32F type
+//! supports only CV_8UC1 source type
+CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum, Stream& stream = Stream::Null());
+
+//! computes squared integral image
+//! result matrix will have 64F type, but will contain 64U values
+//! supports source images of 8UC1 type only
+CV_EXPORTS void sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& stream = Stream::Null());
+
+//! computes vertical sum, supports only CV_32FC1 images
+CV_EXPORTS void columnSum(const GpuMat& src, GpuMat& sum);
+
+//! computes the standard deviation of integral images
+//! supports only CV_32SC1 source type and CV_32FC1 sqr type
+//! output will have CV_32FC1 type
+CV_EXPORTS void rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& stream = Stream::Null());
+
+//! computes Harris cornerness criteria at each image pixel
+CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType = BORDER_REFLECT101);
+CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, double k, int borderType = BORDER_REFLECT101);
+CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, double k, 
+                             int borderType = BORDER_REFLECT101, Stream& stream = Stream::Null());
+
+//! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
+CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
+CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
+CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, 
+    int borderType=BORDER_REFLECT101, Stream& stream = Stream::Null());
+
+//! performs per-element multiplication of two full (not packed) Fourier spectrums
+//! supports 32FC2 matrixes only (interleaved format)
+CV_EXPORTS void mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false, Stream& stream = Stream::Null());
+
+//! performs per-element multiplication of two full (not packed) Fourier spectrums
+//! supports 32FC2 matrixes only (interleaved format)
+CV_EXPORTS void mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false, Stream& stream = Stream::Null());
+
+//! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
+//! Param dft_size is the size of DFT transform.
+//! 
+//! If the source matrix is not continous, then additional copy will be done,
+//! so to avoid copying ensure the source matrix is continous one. If you want to use
+//! preallocated output ensure it is continuous too, otherwise it will be reallocated.
+//!
+//! Being implemented via CUFFT real-to-complex transform result contains only non-redundant values
+//! in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.
+//!
+//! For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.
+CV_EXPORTS void dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0, Stream& stream = Stream::Null());
+
+//! computes convolution (or cross-correlation) of two images using discrete Fourier transform
+//! supports source images of 32FC1 type only
+//! result matrix will have 32FC1 type
+struct CV_EXPORTS ConvolveBuf;
+CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr = false);
+CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream = Stream::Null());
+
+struct CV_EXPORTS ConvolveBuf
+{
+    ConvolveBuf() {}
+    ConvolveBuf(Size image_size, Size templ_size) 
+        { create(image_size, templ_size); }
+    void create(Size image_size, Size templ_size);
+    void create(Size image_size, Size templ_size, Size block_size);
+
+private:
+    static Size estimateBlockSize(Size result_size, Size templ_size);
+    friend void convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&, Stream& stream);
+
+    Size result_size;
+    Size block_size;
+    Size dft_size;
+    int spect_len;
+
+    GpuMat image_spect, templ_spect, result_spect;
+    GpuMat image_block, templ_block, result_data;
+};
+
+//! computes the proximity map for the raster template and the image where the template is searched for
+CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, Stream& stream = Stream::Null());
+
+//! smoothes the source image and downsamples it
+CV_EXPORTS void pyrDown(const GpuMat& src, GpuMat& dst, int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null());
+
+//! upsamples the source image and then smoothes it
+CV_EXPORTS void pyrUp(const GpuMat& src, GpuMat& dst, int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null());
+
+//! performs linear blending of two images
+//! to avoid accuracy errors sum of weigths shouldn't be very close to zero
+CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
+                            GpuMat& result, Stream& stream = Stream::Null());
 
-        ////////////////////////////// Matrix reductions //////////////////////////////
-
-        //! computes mean value and standard deviation of all or selected array elements
-        //! supports only CV_8UC1 type
-        CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
-
-        //! computes norm of array
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports all matrices except 64F
-        CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
-
-        //! computes norm of array
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports all matrices except 64F
-        CV_EXPORTS double norm(const GpuMat& src1, int normType, GpuMat& buf);
-
-        //! computes norm of the difference between two arrays
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports only CV_8UC1 type
-        CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
-
-        //! computes sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sum(const GpuMat& src);
-
-        //! computes sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
-
-        //! computes sum of array elements absolute values
-        //! supports only single channel images
-        CV_EXPORTS Scalar absSum(const GpuMat& src);
-
-        //! computes sum of array elements absolute values
-        //! supports only single channel images
-        CV_EXPORTS Scalar absSum(const GpuMat& src, GpuMat& buf);
-
-        //! computes squared sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sqrSum(const GpuMat& src);
-
-        //! computes squared sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
-
-        //! finds global minimum and maximum array elements and returns their values
-        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
-
-        //! finds global minimum and maximum array elements and returns their values
-        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
-
-        //! finds global minimum and maximum array elements and returns their values with locations
-        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
-                                  const GpuMat& mask=GpuMat());
-
-        //! finds global minimum and maximum array elements and returns their values with locations
-        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
-                                  const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
-
-        //! counts non-zero array elements
-        CV_EXPORTS int countNonZero(const GpuMat& src);
-
-        //! counts non-zero array elements
-        CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
-
-        //! reduces a matrix to a vector
-        CV_EXPORTS void reduce(const GpuMat& mtx, GpuMat& vec, int dim, int reduceOp, int dtype = -1, Stream& stream = Stream::Null());
-
-
-        ///////////////////////////// Calibration 3D //////////////////////////////////
-
-        CV_EXPORTS void transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
-                                        GpuMat& dst, Stream& stream = Stream::Null());
-
-        CV_EXPORTS void projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
-                                      const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, 
-                                      Stream& stream = Stream::Null());
-
-        CV_EXPORTS void solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat,
-                                       const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false,
-                                       int num_iters=100, float max_dist=8.0, int min_inlier_count=100, 
-                                       vector<int>* inliers=NULL);
-
-        //////////////////////////////// Image Labeling ////////////////////////////////
-
-        //!performs labeling via graph cuts
-        CV_EXPORTS void graphcut(GpuMat& terminals, GpuMat& leftTransp, GpuMat& rightTransp, GpuMat& top, GpuMat& bottom, GpuMat& labels, GpuMat& buf, Stream& stream = Stream::Null());
-
-        ////////////////////////////////// Histograms //////////////////////////////////
-
-        //! Compute levels with even distribution. levels will have 1 row and nLevels cols and CV_32SC1 type.
-        CV_EXPORTS void evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel);
-        //! Calculates histogram with evenly distributed bins for signle channel source.
-        //! Supports CV_8UC1, CV_16UC1 and CV_16SC1 source types.
-        //! Output hist will have one row and histSize cols and CV_32SC1 type.
-        CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
-        CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, GpuMat& buf, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
-        //! Calculates histogram with evenly distributed bins for four-channel source.
-        //! All channels of source are processed separately.
-        //! Supports CV_8UC4, CV_16UC4 and CV_16SC4 source types.
-        //! Output hist[i] will have one row and histSize[i] cols and CV_32SC1 type.
-        CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
-        CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], GpuMat& buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
-        //! Calculates histogram with bins determined by levels array.
-        //! levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
-        //! Supports CV_8UC1, CV_16UC1, CV_16SC1 and CV_32FC1 source types.
-        //! Output hist will have one row and (levels.cols-1) cols and CV_32SC1 type.
-        CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, Stream& stream = Stream::Null());
-        CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, Stream& stream = Stream::Null());
-        //! Calculates histogram with bins determined by levels array.
-        //! All levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
-        //! All channels of source are processed separately.
-        //! Supports CV_8UC4, CV_16UC4, CV_16SC4 and CV_32FC4 source types.
-        //! Output hist[i] will have one row and (levels[i].cols-1) cols and CV_32SC1 type.
-        CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], Stream& stream = Stream::Null());
-        CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buf, Stream& stream = Stream::Null());
-        
-        //! 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 ////////////////////////////////
-
-        class CV_EXPORTS StereoBM_GPU
-        {
-        public:
-            enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 };
-
-            enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 };
-
-            //! the default constructor
-            StereoBM_GPU();
-            //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8.
-            StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ);
-
-            //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
-            //! Output disparity has CV_8U type.
-            void operator() ( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
-
-            //! Some heuristics that tries to estmate
-            // if current GPU will be faster than CPU in this algorithm.
-            // It queries current active device.
-            static bool checkIfGpuCallReasonable();
-
-            int preset;
-            int ndisp;
-            int winSize;
-
-            // If avergeTexThreshold  == 0 => post procesing is disabled
-            // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image
-            // SumOfHorizontalGradiensInWindow(x, y, winSize) < (winSize * winSize) * avergeTexThreshold
-            // i.e. input left image is low textured.
-            float avergeTexThreshold;
-        private:
-            GpuMat minSSD, leBuf, riBuf;
-        };
-
-        ////////////////////////// StereoBeliefPropagation ///////////////////////////
-        // "Efficient Belief Propagation for Early Vision"
-        // P.Felzenszwalb
-
-        class CV_EXPORTS StereoBeliefPropagation
-        {
-        public:
-            enum { DEFAULT_NDISP  = 64 };
-            enum { DEFAULT_ITERS  = 5  };
-            enum { DEFAULT_LEVELS = 5  };
-
-            static void estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels);
-
-            //! the default constructor
-            explicit StereoBeliefPropagation(int ndisp  = DEFAULT_NDISP,
-                int iters  = DEFAULT_ITERS,
-                int levels = DEFAULT_LEVELS,
-                int msg_type = CV_32F);
-
-            //! the full constructor taking the number of disparities, number of BP iterations on each level,
-            //! number of levels, truncation of data cost, data weight,
-            //! truncation of discontinuity cost and discontinuity single jump
-            //! DataTerm = data_weight * min(fabs(I2-I1), max_data_term)
-            //! DiscTerm = min(disc_single_jump * fabs(f1-f2), max_disc_term)
-            //! please see paper for more details
-            StereoBeliefPropagation(int ndisp, int iters, int levels,
-                float max_data_term, float data_weight,
-                float max_disc_term, float disc_single_jump,
-                int msg_type = CV_32F);
-
-            //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair,
-            //! if disparity is empty output type will be CV_16S else output type will be disparity.type().
-            void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
-
-
-            //! version for user specified data term
-            void operator()(const GpuMat& data, GpuMat& disparity, Stream& stream = Stream::Null());
-
-            int ndisp;
-
-            int iters;
-            int levels;
-
-            float max_data_term;
-            float data_weight;
-            float max_disc_term;
-            float disc_single_jump;
-
-            int msg_type;
-        private:
-            GpuMat u, d, l, r, u2, d2, l2, r2;
-            std::vector<GpuMat> datas;
-            GpuMat out;
-        };
-
-        /////////////////////////// StereoConstantSpaceBP ///////////////////////////
-        // "A Constant-Space Belief Propagation Algorithm for Stereo Matching"
-        // Qingxiong Yang, Liang Wang, Narendra Ahuja
-        // http://vision.ai.uiuc.edu/~qyang6/
-
-        class CV_EXPORTS StereoConstantSpaceBP
-        {
-        public:
-            enum { DEFAULT_NDISP    = 128 };
-            enum { DEFAULT_ITERS    = 8   };
-            enum { DEFAULT_LEVELS   = 4   };
-            enum { DEFAULT_NR_PLANE = 4   };
-
-            static void estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane);
-
-            //! the default constructor
-            explicit StereoConstantSpaceBP(int ndisp    = DEFAULT_NDISP,
-                int iters    = DEFAULT_ITERS,
-                int levels   = DEFAULT_LEVELS,
-                int nr_plane = DEFAULT_NR_PLANE,
-                int msg_type = CV_32F);
-
-            //! the full constructor taking the number of disparities, number of BP iterations on each level,
-            //! number of levels, number of active disparity on the first level, truncation of data cost, data weight,
-            //! truncation of discontinuity cost, discontinuity single jump and minimum disparity threshold
-            StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane,
-                float max_data_term, float data_weight, float max_disc_term, float disc_single_jump,
-                int min_disp_th = 0,
-                int msg_type = CV_32F);
-
-            //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair,
-            //! if disparity is empty output type will be CV_16S else output type will be disparity.type().
-            void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
-
-            int ndisp;
-
-            int iters;
-            int levels;
-
-            int nr_plane;
-
-            float max_data_term;
-            float data_weight;
-            float max_disc_term;
-            float disc_single_jump;
-
-            int min_disp_th;
-
-            int msg_type;
-
-            bool use_local_init_data_cost;
-        private:
-            GpuMat u[2], d[2], l[2], r[2];
-            GpuMat disp_selected_pyr[2];
-
-            GpuMat data_cost;
-            GpuMat data_cost_selected;
-
-            GpuMat temp;
-
-            GpuMat out;
-        };
-
-        /////////////////////////// DisparityBilateralFilter ///////////////////////////
-        // Disparity map refinement using joint bilateral filtering given a single color image.
-        // Qingxiong Yang, Liang Wang, Narendra Ahuja
-        // http://vision.ai.uiuc.edu/~qyang6/
-
-        class CV_EXPORTS DisparityBilateralFilter
-        {
-        public:
-            enum { DEFAULT_NDISP  = 64 };
-            enum { DEFAULT_RADIUS = 3 };
-            enum { DEFAULT_ITERS  = 1 };
+struct CV_EXPORTS CannyBuf;
 
-            //! the default constructor
-            explicit DisparityBilateralFilter(int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS);
+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);
 
-            //! the full constructor taking the number of disparities, filter radius,
-            //! number of iterations, truncation of data continuity, truncation of disparity continuity
-            //! and filter range sigma
-            DisparityBilateralFilter(int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range);
+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_);
 
-            //! the disparity map refinement operator. Refine disparity map using joint bilateral filtering given a single color image.
-            //! disparity must have CV_8U or CV_16S type, image must have CV_8UC1 or CV_8UC3 type.
-            void operator()(const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream = Stream::Null());
+    void create(const Size& image_size, int apperture_size = 3);
+    
+    void release();
 
-        private:
-            int ndisp;
-            int radius;
-            int iters;
+    GpuMat dx, dy;
+    GpuMat dx_buf, dy_buf;
+    GpuMat edgeBuf;
+    GpuMat trackBuf1, trackBuf2;
+    Ptr<FilterEngine_GPU> filterDX, filterDY;
+};
 
-            float edge_threshold;
-            float max_disc_threshold;
-            float sigma_range;
+////////////////////////////// Matrix reductions //////////////////////////////
 
-            GpuMat table_color;
-            GpuMat table_space;
-        };
+//! computes mean value and standard deviation of all or selected array elements
+//! supports only CV_8UC1 type
+CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
+
+//! computes norm of array
+//! supports NORM_INF, NORM_L1, NORM_L2
+//! supports all matrices except 64F
+CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
+
+//! computes norm of array
+//! supports NORM_INF, NORM_L1, NORM_L2
+//! supports all matrices except 64F
+CV_EXPORTS double norm(const GpuMat& src1, int normType, GpuMat& buf);
+
+//! computes norm of the difference between two arrays
+//! supports NORM_INF, NORM_L1, NORM_L2
+//! supports only CV_8UC1 type
+CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
+
+//! computes sum of array elements
+//! supports only single channel images
+CV_EXPORTS Scalar sum(const GpuMat& src);
+
+//! computes sum of array elements
+//! supports only single channel images
+CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
+
+//! computes sum of array elements absolute values
+//! supports only single channel images
+CV_EXPORTS Scalar absSum(const GpuMat& src);
+
+//! computes sum of array elements absolute values
+//! supports only single channel images
+CV_EXPORTS Scalar absSum(const GpuMat& src, GpuMat& buf);
+
+//! computes squared sum of array elements
+//! supports only single channel images
+CV_EXPORTS Scalar sqrSum(const GpuMat& src);
+
+//! computes squared sum of array elements
+//! supports only single channel images
+CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
+
+//! finds global minimum and maximum array elements and returns their values
+CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
+
+//! finds global minimum and maximum array elements and returns their values
+CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
+
+//! finds global minimum and maximum array elements and returns their values with locations
+CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
+                          const GpuMat& mask=GpuMat());
+
+//! finds global minimum and maximum array elements and returns their values with locations
+CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
+                          const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
+
+//! counts non-zero array elements
+CV_EXPORTS int countNonZero(const GpuMat& src);
+
+//! counts non-zero array elements
+CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
+
+//! reduces a matrix to a vector
+CV_EXPORTS void reduce(const GpuMat& mtx, GpuMat& vec, int dim, int reduceOp, int dtype = -1, Stream& stream = Stream::Null());
+
+
+///////////////////////////// Calibration 3D //////////////////////////////////
+
+CV_EXPORTS void transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
+                                GpuMat& dst, Stream& stream = Stream::Null());
+
+CV_EXPORTS void projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
+                              const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, 
+                              Stream& stream = Stream::Null());
+
+CV_EXPORTS void solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat,
+                               const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false,
+                               int num_iters=100, float max_dist=8.0, int min_inlier_count=100, 
+                               std::vector<int>* inliers=NULL);
+
+//////////////////////////////// Image Labeling ////////////////////////////////
+
+//!performs labeling via graph cuts
+CV_EXPORTS void graphcut(GpuMat& terminals, GpuMat& leftTransp, GpuMat& rightTransp, GpuMat& top, GpuMat& bottom, GpuMat& labels, 
+                         GpuMat& buf, Stream& stream = Stream::Null());
+
+////////////////////////////////// Histograms //////////////////////////////////
+
+//! Compute levels with even distribution. levels will have 1 row and nLevels cols and CV_32SC1 type.
+CV_EXPORTS void evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel);
+//! Calculates histogram with evenly distributed bins for signle channel source.
+//! Supports CV_8UC1, CV_16UC1 and CV_16SC1 source types.
+//! Output hist will have one row and histSize cols and CV_32SC1 type.
+CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
+CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, GpuMat& buf, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
+//! Calculates histogram with evenly distributed bins for four-channel source.
+//! All channels of source are processed separately.
+//! Supports CV_8UC4, CV_16UC4 and CV_16SC4 source types.
+//! Output hist[i] will have one row and histSize[i] cols and CV_32SC1 type.
+CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
+CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], GpuMat& buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
+//! Calculates histogram with bins determined by levels array.
+//! levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
+//! Supports CV_8UC1, CV_16UC1, CV_16SC1 and CV_32FC1 source types.
+//! Output hist will have one row and (levels.cols-1) cols and CV_32SC1 type.
+CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, Stream& stream = Stream::Null());
+CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, Stream& stream = Stream::Null());
+//! Calculates histogram with bins determined by levels array.
+//! All levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
+//! All channels of source are processed separately.
+//! Supports CV_8UC4, CV_16UC4, CV_16SC4 and CV_32FC4 source types.
+//! Output hist[i] will have one row and (levels[i].cols-1) cols and CV_32SC1 type.
+CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], Stream& stream = Stream::Null());
+CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buf, Stream& stream = Stream::Null());
+
+//! 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 ////////////////////////////////
+
+class CV_EXPORTS StereoBM_GPU
+{
+public:
+    enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 };
 
+    enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 };
 
-        //////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
+    //! the default constructor
+    StereoBM_GPU();
+    //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8.
+    StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ);
 
-        struct CV_EXPORTS HOGDescriptor
-        {
-            enum { DEFAULT_WIN_SIGMA = -1 };
-            enum { DEFAULT_NLEVELS = 64 };
-            enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };
+    //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
+    //! Output disparity has CV_8U type.
+    void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
 
-            HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16),
-                          Size block_stride=Size(8, 8), Size cell_size=Size(8, 8),
-                          int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA,
-                          double threshold_L2hys=0.2, bool gamma_correction=true,
-                          int nlevels=DEFAULT_NLEVELS);
+    //! Some heuristics that tries to estmate
+    // if current GPU will be faster than CPU in this algorithm.
+    // It queries current active device.
+    static bool checkIfGpuCallReasonable();
 
-            size_t getDescriptorSize() const;
-            size_t getBlockHistogramSize() const;
+    int preset;
+    int ndisp;
+    int winSize;
 
-            void setSVMDetector(const vector<float>& detector);
+    // If avergeTexThreshold  == 0 => post procesing is disabled
+    // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image
+    // SumOfHorizontalGradiensInWindow(x, y, winSize) < (winSize * winSize) * avergeTexThreshold
+    // i.e. input left image is low textured.
+    float avergeTexThreshold;
 
-            static vector<float> getDefaultPeopleDetector();
-            static vector<float> getPeopleDetector48x96();
-            static vector<float> getPeopleDetector64x128();
+private:
+    GpuMat minSSD, leBuf, riBuf;
+};
 
-            void detect(const GpuMat& img, vector<Point>& found_locations, 
-                        double hit_threshold=0, Size win_stride=Size(), 
-                        Size padding=Size());
+////////////////////////// StereoBeliefPropagation ///////////////////////////
+// "Efficient Belief Propagation for Early Vision"
+// P.Felzenszwalb
 
-            void detectMultiScale(const GpuMat& img, vector<Rect>& found_locations,
-                                  double hit_threshold=0, Size win_stride=Size(), 
-                                  Size padding=Size(), double scale0=1.05, 
-                                  int group_threshold=2);
+class CV_EXPORTS StereoBeliefPropagation
+{
+public:
+    enum { DEFAULT_NDISP  = 64 };
+    enum { DEFAULT_ITERS  = 5  };
+    enum { DEFAULT_LEVELS = 5  };
+
+    static void estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels);
+
+    //! the default constructor
+    explicit StereoBeliefPropagation(int ndisp  = DEFAULT_NDISP,
+                                     int iters  = DEFAULT_ITERS,
+                                     int levels = DEFAULT_LEVELS,
+                                     int msg_type = CV_32F);
+
+    //! the full constructor taking the number of disparities, number of BP iterations on each level,
+    //! number of levels, truncation of data cost, data weight,
+    //! truncation of discontinuity cost and discontinuity single jump
+    //! DataTerm = data_weight * min(fabs(I2-I1), max_data_term)
+    //! DiscTerm = min(disc_single_jump * fabs(f1-f2), max_disc_term)
+    //! please see paper for more details
+    StereoBeliefPropagation(int ndisp, int iters, int levels,
+        float max_data_term, float data_weight,
+        float max_disc_term, float disc_single_jump,
+        int msg_type = CV_32F);
+
+    //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair,
+    //! if disparity is empty output type will be CV_16S else output type will be disparity.type().
+    void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
+
+
+    //! version for user specified data term
+    void operator()(const GpuMat& data, GpuMat& disparity, Stream& stream = Stream::Null());
+
+    int ndisp;
+
+    int iters;
+    int levels;
+
+    float max_data_term;
+    float data_weight;
+    float max_disc_term;
+    float disc_single_jump;
+
+    int msg_type;
+private:
+    GpuMat u, d, l, r, u2, d2, l2, r2;
+    std::vector<GpuMat> datas;
+    GpuMat out;
+};
+
+/////////////////////////// StereoConstantSpaceBP ///////////////////////////
+// "A Constant-Space Belief Propagation Algorithm for Stereo Matching"
+// Qingxiong Yang, Liang Wang, Narendra Ahuja
+// http://vision.ai.uiuc.edu/~qyang6/
+
+class CV_EXPORTS StereoConstantSpaceBP
+{
+public:
+    enum { DEFAULT_NDISP    = 128 };
+    enum { DEFAULT_ITERS    = 8   };
+    enum { DEFAULT_LEVELS   = 4   };
+    enum { DEFAULT_NR_PLANE = 4   };
 
-            void getDescriptors(const GpuMat& img, Size win_stride, 
-                                GpuMat& descriptors,
-                                int descr_format=DESCR_FORMAT_COL_BY_COL);
+    static void estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane);
 
-            Size win_size;
-            Size block_size;
-            Size block_stride;
-            Size cell_size;
-            int nbins;
-            double win_sigma;
-            double threshold_L2hys;
-            bool gamma_correction;
-            int nlevels;
+    //! the default constructor
+    explicit StereoConstantSpaceBP(int ndisp    = DEFAULT_NDISP,
+                                   int iters    = DEFAULT_ITERS,
+                                   int levels   = DEFAULT_LEVELS,
+                                   int nr_plane = DEFAULT_NR_PLANE,
+                                   int msg_type = CV_32F);
 
-        protected:
-            void computeBlockHistograms(const GpuMat& img);
-            void computeGradient(const GpuMat& img, GpuMat& grad, GpuMat& qangle);
+    //! the full constructor taking the number of disparities, number of BP iterations on each level,
+    //! number of levels, number of active disparity on the first level, truncation of data cost, data weight,
+    //! truncation of discontinuity cost, discontinuity single jump and minimum disparity threshold
+    StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane,
+        float max_data_term, float data_weight, float max_disc_term, float disc_single_jump,
+        int min_disp_th = 0,
+        int msg_type = CV_32F);
 
-            double getWinSigma() const;
-            bool checkDetectorSize() const;
+    //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair,
+    //! if disparity is empty output type will be CV_16S else output type will be disparity.type().
+    void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
 
-            static int numPartsWithin(int size, int part_size, int stride);
-            static Size numPartsWithin(Size size, Size part_size, Size stride);
+    int ndisp;
 
-            // Coefficients of the separating plane
-            float free_coef;
-            GpuMat detector;
-
-            // Results of the last classification step
-            GpuMat labels, labels_buf;
-            Mat labels_host;
-
-            // Results of the last histogram evaluation step
-            GpuMat block_hists, block_hists_buf;
-
-            // Gradients conputation results
-            GpuMat grad, qangle, grad_buf, qangle_buf;
-
-			// returns subbuffer with required size, reallocates buffer if nessesary.
-			static GpuMat getBuffer(const Size& sz, int type, GpuMat& buf);
-			static GpuMat getBuffer(int rows, int cols, int type, GpuMat& buf);
-
-			std::vector<GpuMat> image_scales;
-        };
-
-
-        ////////////////////////////////// BruteForceMatcher //////////////////////////////////
-
-        class CV_EXPORTS BruteForceMatcher_GPU_base
-        {
-        public:
-            enum DistType {L1Dist = 0, L2Dist, HammingDist};
-
-            explicit BruteForceMatcher_GPU_base(DistType distType = L2Dist);
-
-            // Add descriptors to train descriptor collection
-            void add(const std::vector<GpuMat>& descCollection);
-
-            // Get train descriptors collection
-            const std::vector<GpuMat>& getTrainDescriptors() const;
-
-            // Clear train descriptors collection
-            void clear();
-
-            // Return true if there are not train descriptors in collection
-            bool empty() const;
-
-            // Return true if the matcher supports mask in match methods
-            bool isMaskSupported() const;
-
-            // Find one best match for each query descriptor
-            void matchSingle(const GpuMat& query, const GpuMat& train, 
-                GpuMat& trainIdx, GpuMat& distance, 
-                const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
-
-            // Download trainIdx and distance and convert it to CPU vector with DMatch
-            static void matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>& matches);
-            // Convert trainIdx and distance to vector with DMatch
-            static void matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches);
-
-            // Find one best match for each query descriptor
-            void match(const GpuMat& query, const GpuMat& train, std::vector<DMatch>& matches, const GpuMat& mask = GpuMat());
-
-            // Make gpu collection of trains and masks in suitable format for matchCollection function
-            void makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
-
-            // Find one best match from train collection for each query descriptor
-            void matchCollection(const GpuMat& query, const GpuMat& trainCollection, 
-                GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
-                const GpuMat& masks = GpuMat(), Stream& stream = Stream::Null());
-
-            // Download trainIdx, imgIdx and distance and convert it to vector with DMatch
-            static void matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>& matches);
-            // Convert trainIdx, imgIdx and distance to vector with DMatch
-            static void matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches);
-
-            // Find one best match from train collection for each query descriptor.
-            void match(const GpuMat& query, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
-
-            // Find k best matches for each query descriptor (in increasing order of distances)
-            void knnMatchSingle(const GpuMat& query, const GpuMat& train,
-                GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k,
-                const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
-
-            // Download trainIdx and distance and convert it to vector with DMatch
-            // compactResult is used when mask is not empty. If compactResult is false matches
-            // vector will have the same size as queryDescriptors rows. If compactResult is true
-            // matches vector will not contain matches for fully masked out query descriptors.
-            static void knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-            // Convert trainIdx and distance to vector with DMatch
-            static void knnMatchConvert(const Mat& trainIdx, const Mat& distance,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-
-            // Find k best matches for each query descriptor (in increasing order of distances).
-            // compactResult is used when mask is not empty. If compactResult is false matches
-            // vector will have the same size as queryDescriptors rows. If compactResult is true
-            // matches vector will not contain matches for fully masked out query descriptors.
-            void knnMatch(const GpuMat& query, const GpuMat& train,
-                std::vector< std::vector<DMatch> >& matches, int k, const GpuMat& mask = GpuMat(),
-                bool compactResult = false);
-
-            // Find k best matches from train collection for each query descriptor (in increasing order of distances)
-            void knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection,
-                GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
-                const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null());
-
-            // Download trainIdx and distance and convert it to vector with DMatch
-            // compactResult is used when mask is not empty. If compactResult is false matches
-            // vector will have the same size as queryDescriptors rows. If compactResult is true
-            // matches vector will not contain matches for fully masked out query descriptors.
-            static void knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-            // Convert trainIdx and distance to vector with DMatch
-            static void knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-
-            // Find k best matches  for each query descriptor (in increasing order of distances).
-            // compactResult is used when mask is not empty. If compactResult is false matches
-            // vector will have the same size as queryDescriptors rows. If compactResult is true
-            // matches vector will not contain matches for fully masked out query descriptors.
-            void knnMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, int k,
-                const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
-
-            // Find best matches for each query descriptor which have distance less than maxDistance.
-            // nMatches.at<int>(0, queryIdx) will contain matches count for queryIdx.
-            // carefully nMatches can be greater than trainIdx.cols - it means that matcher didn't find all matches,
-            // because it didn't have enough memory.
-            // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nTrain / 100), 10),
-            // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
-            // Matches doesn't sorted.
-            void radiusMatchSingle(const GpuMat& query, const GpuMat& train,
-                GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
-                const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
-
-            // Download trainIdx, nMatches and distance and convert it to vector with DMatch.
-            // matches will be sorted in increasing order of distances.
-            // compactResult is used when mask is not empty. If compactResult is false matches
-            // vector will have the same size as queryDescriptors rows. If compactResult is true
-            // matches vector will not contain matches for fully masked out query descriptors.
-            static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-            // Convert trainIdx, nMatches and distance to vector with DMatch.
-            static void radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-
-            // Find best matches for each query descriptor which have distance less than maxDistance
-            // in increasing order of distances).
-            void radiusMatch(const GpuMat& query, const GpuMat& train,
-                std::vector< std::vector<DMatch> >& matches, float maxDistance,
-                const GpuMat& mask = GpuMat(), bool compactResult = false);
-
-            // Find best matches for each query descriptor which have distance less than maxDistance.
-            // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nQuery / 100), 10),
-            // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
-            // Matches doesn't sorted.
-            void radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
-                const std::vector<GpuMat>& masks = std::vector<GpuMat>(), Stream& stream = Stream::Null());
-
-            // Download trainIdx, imgIdx, nMatches and distance and convert it to vector with DMatch.
-            // matches will be sorted in increasing order of distances.
-            // compactResult is used when mask is not empty. If compactResult is false matches
-            // vector will have the same size as queryDescriptors rows. If compactResult is true
-            // matches vector will not contain matches for fully masked out query descriptors.
-            static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-            // Convert trainIdx, nMatches and distance to vector with DMatch.
-            static void radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches,
-                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
-
-            // Find best matches from train collection for each query descriptor which have distance less than
-            // maxDistance (in increasing order of distances).
-            void radiusMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, float maxDistance,
-                const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
-
-            DistType distType;
-
-        private:
-            std::vector<GpuMat> trainDescCollection;
-        };
-
-        template <class Distance>
-        class CV_EXPORTS BruteForceMatcher_GPU;
-
-        template <typename T>
-        class CV_EXPORTS BruteForceMatcher_GPU< L1<T> > : public BruteForceMatcher_GPU_base
-        {
-        public:
-            explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(L1Dist) {}
-            explicit BruteForceMatcher_GPU(L1<T> /*d*/) : BruteForceMatcher_GPU_base(L1Dist) {}
-        };
-        template <typename T>
-        class CV_EXPORTS BruteForceMatcher_GPU< L2<T> > : public BruteForceMatcher_GPU_base
-        {
-        public:
-            explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(L2Dist) {}
-            explicit BruteForceMatcher_GPU(L2<T> /*d*/) : BruteForceMatcher_GPU_base(L2Dist) {}
-        };
-        template <> class CV_EXPORTS BruteForceMatcher_GPU< Hamming > : public BruteForceMatcher_GPU_base
-        {
-        public:
-            explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(HammingDist) {}
-            explicit BruteForceMatcher_GPU(Hamming /*d*/) : BruteForceMatcher_GPU_base(HammingDist) {}
-        };
-
-        ////////////////////////////////// CascadeClassifier_GPU //////////////////////////////////////////
-        // The cascade classifier class for object detection.
-        class CV_EXPORTS CascadeClassifier_GPU
-        {
-        public:
-            CascadeClassifier_GPU();
-            CascadeClassifier_GPU(const string& filename);
-            ~CascadeClassifier_GPU();
-
-            bool empty() const;
-            bool load(const string& filename);
-            void release();
-
-            /* returns number of detected objects */
-            int detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size());
-
-            bool findLargestObject;
-            bool visualizeInPlace;
-
-            Size getClassifierSize() const;
-        private:
-
-            struct CascadeClassifierImpl;
-            CascadeClassifierImpl* impl;
-        };
-
-        ////////////////////////////////// SURF //////////////////////////////////////////
-
-        class CV_EXPORTS SURF_GPU : public CvSURFParams
-        {
-        public:
-            enum KeypointLayout 
-            {
-                SF_X = 0,
-                SF_Y,
-                SF_LAPLACIAN,
-                SF_SIZE,
-                SF_DIR,
-                SF_HESSIAN,
-                SF_FEATURE_STRIDE
-            };
-
-            //! the default constructor
-            SURF_GPU();
-            //! the full constructor taking all the necessary parameters
-            explicit SURF_GPU(double _hessianThreshold, int _nOctaves=4,
-                 int _nOctaveLayers=2, bool _extended=false, float _keypointsRatio=0.01f, bool _upright = false);
-
-            //! returns the descriptor size in float's (64 or 128)
-            int descriptorSize() const;
-
-            //! upload host keypoints to device memory
-            void uploadKeypoints(const vector<KeyPoint>& keypoints, GpuMat& keypointsGPU);
-            //! download keypoints from device to host memory
-            void downloadKeypoints(const GpuMat& keypointsGPU, vector<KeyPoint>& keypoints);
-
-            //! download descriptors from device to host memory
-            void downloadDescriptors(const GpuMat& descriptorsGPU, vector<float>& descriptors);
-            
-            //! finds the keypoints using fast hessian detector used in SURF
-            //! supports CV_8UC1 images
-            //! keypoints will have nFeature cols and 6 rows
-            //! keypoints.ptr<float>(SF_X)[i] will contain x coordinate of i'th feature
-            //! keypoints.ptr<float>(SF_Y)[i] will contain y coordinate of i'th feature
-            //! keypoints.ptr<float>(SF_LAPLACIAN)[i] will contain laplacian sign of i'th feature
-            //! keypoints.ptr<float>(SF_SIZE)[i] will contain size of i'th feature
-            //! keypoints.ptr<float>(SF_DIR)[i] will contain orientation of i'th feature
-            //! keypoints.ptr<float>(SF_HESSIAN)[i] will contain response of i'th feature
-            void operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints);
-            //! finds the keypoints and computes their descriptors. 
-            //! Optionally it can compute descriptors for the user-provided keypoints and recompute keypoints direction
-            void operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors, 
-                bool useProvidedKeypoints = false);
-
-            void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints);
-            void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, GpuMat& descriptors, 
-                bool useProvidedKeypoints = false);
-
-            void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, std::vector<float>& descriptors, 
-                bool useProvidedKeypoints = false);
-
-            void releaseMemory();
-
-            //! max keypoints = min(keypointsRatio * img.size().area(), 65535)
-            float keypointsRatio;
-
-            GpuMat sum, mask1, maskSum, intBuffer;
-
-            GpuMat det, trace;
-
-            GpuMat maxPosBuffer;
-        };
-
-        ////////////////////////////////// Optical Flow //////////////////////////////////////////
-
-        class CV_EXPORTS BroxOpticalFlow
-        {
-        public:
-            BroxOpticalFlow(float alpha_, float gamma_, float scale_factor_, int inner_iterations_, int outer_iterations_, int solver_iterations_) :
-                alpha(alpha_), gamma(gamma_), scale_factor(scale_factor_), 
-                inner_iterations(inner_iterations_), outer_iterations(outer_iterations_), solver_iterations(solver_iterations_)
-            {
-            }
-
-            //! Compute optical flow
-            //! frame0 - source frame (supports only CV_32FC1 type)
-            //! frame1 - frame to track (with the same size and type as frame0)
-            //! u      - flow horizontal component (along x axis)
-            //! v      - flow vertical component (along y axis)
-            void operator ()(const GpuMat& frame0, const GpuMat& frame1, GpuMat& u, GpuMat& v, Stream& stream = Stream::Null());
-
-            //! flow smoothness
-	        float alpha;
-
-	        //! gradient constancy importance
-	        float gamma;
-
-	        //! pyramid scale factor
-	        float scale_factor;
-
-	        //! number of lagged non-linearity iterations (inner loop)
-	        int inner_iterations;
-
-	        //! number of warping iterations (number of pyramid levels)
-	        int outer_iterations;
-
-	        //! number of linear system solver iterations
-	        int solver_iterations;
-
-            GpuMat 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)
-        //! fu       - forward horizontal displacement
-        //! fv       - forward vertical displacement
-        //! bu       - backward horizontal displacement
-        //! bv       - backward vertical displacement
-        //! pos      - new frame position
-        //! newFrame - new frame
-        //! buf      - temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 GpuMat;
-        //!            occlusion masks            0, occlusion masks            1,
-        //!            interpolated forward flow  0, interpolated forward flow  1,
-        //!            interpolated backward flow 0, interpolated backward flow 1
-        //!            
-        CV_EXPORTS void interpolateFrames(const GpuMat& frame0, const GpuMat& frame1, 
-            const GpuMat& fu, const GpuMat& fv,
-            const GpuMat& bu, const GpuMat& bv, 
-            float pos, GpuMat& newFrame, GpuMat& buf,
-            Stream& stream = Stream::Null());
+    int iters;
+    int levels;
 
-    }
+    int nr_plane;
 
-    //! Speckle filtering - filters small connected components on diparity image.
-    //! It sets pixel (x,y) to newVal if it coresponds to small CC with size < maxSpeckleSize.
-    //! Threshold for border between CC is diffThreshold;
-    CV_EXPORTS void filterSpeckles( Mat& img, uchar newVal, int maxSpeckleSize, uchar diffThreshold, Mat& buf);
+    float max_data_term;
+    float data_weight;
+    float max_disc_term;
+    float disc_single_jump;
 
-}
-#include "opencv2/gpu/matrix_operations.hpp"
+    int min_disp_th;
+
+    int msg_type;
+
+    bool use_local_init_data_cost;
+private:
+    GpuMat u[2], d[2], l[2], r[2];
+    GpuMat disp_selected_pyr[2];
+
+    GpuMat data_cost;
+    GpuMat data_cost_selected;
+
+    GpuMat temp;
+
+    GpuMat out;
+};
+
+/////////////////////////// DisparityBilateralFilter ///////////////////////////
+// Disparity map refinement using joint bilateral filtering given a single color image.
+// Qingxiong Yang, Liang Wang, Narendra Ahuja
+// http://vision.ai.uiuc.edu/~qyang6/
+
+class CV_EXPORTS DisparityBilateralFilter
+{
+public:
+    enum { DEFAULT_NDISP  = 64 };
+    enum { DEFAULT_RADIUS = 3 };
+    enum { DEFAULT_ITERS  = 1 };
+
+    //! the default constructor
+    explicit DisparityBilateralFilter(int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS);
+
+    //! the full constructor taking the number of disparities, filter radius,
+    //! number of iterations, truncation of data continuity, truncation of disparity continuity
+    //! and filter range sigma
+    DisparityBilateralFilter(int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range);
+
+    //! the disparity map refinement operator. Refine disparity map using joint bilateral filtering given a single color image.
+    //! disparity must have CV_8U or CV_16S type, image must have CV_8UC1 or CV_8UC3 type.
+    void operator()(const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream = Stream::Null());
+
+private:
+    int ndisp;
+    int radius;
+    int iters;
+
+    float edge_threshold;
+    float max_disc_threshold;
+    float sigma_range;
+
+    GpuMat table_color;
+    GpuMat table_space;
+};
+
+
+//////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
+
+struct CV_EXPORTS HOGDescriptor
+{
+    enum { DEFAULT_WIN_SIGMA = -1 };
+    enum { DEFAULT_NLEVELS = 64 };
+    enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };
+
+    HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16),
+                  Size block_stride=Size(8, 8), Size cell_size=Size(8, 8),
+                  int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA,
+                  double threshold_L2hys=0.2, bool gamma_correction=true,
+                  int nlevels=DEFAULT_NLEVELS);
+
+    size_t getDescriptorSize() const;
+    size_t getBlockHistogramSize() const;
+
+    void setSVMDetector(const vector<float>& detector);
+
+    static vector<float> getDefaultPeopleDetector();
+    static vector<float> getPeopleDetector48x96();
+    static vector<float> getPeopleDetector64x128();
+
+    void detect(const GpuMat& img, vector<Point>& found_locations, 
+                double hit_threshold=0, Size win_stride=Size(), 
+                Size padding=Size());
+
+    void detectMultiScale(const GpuMat& img, vector<Rect>& found_locations,
+                          double hit_threshold=0, Size win_stride=Size(), 
+                          Size padding=Size(), double scale0=1.05, 
+                          int group_threshold=2);
+
+    void getDescriptors(const GpuMat& img, Size win_stride, 
+                        GpuMat& descriptors,
+                        int descr_format=DESCR_FORMAT_COL_BY_COL);
+
+    Size win_size;
+    Size block_size;
+    Size block_stride;
+    Size cell_size;
+    int nbins;
+    double win_sigma;
+    double threshold_L2hys;
+    bool gamma_correction;
+    int nlevels;
+
+protected:
+    void computeBlockHistograms(const GpuMat& img);
+    void computeGradient(const GpuMat& img, GpuMat& grad, GpuMat& qangle);
+
+    double getWinSigma() const;
+    bool checkDetectorSize() const;
+
+    static int numPartsWithin(int size, int part_size, int stride);
+    static Size numPartsWithin(Size size, Size part_size, Size stride);
+
+    // Coefficients of the separating plane
+    float free_coef;
+    GpuMat detector;
+
+    // Results of the last classification step
+    GpuMat labels, labels_buf;
+    Mat labels_host;
+
+    // Results of the last histogram evaluation step
+    GpuMat block_hists, block_hists_buf;
+
+    // Gradients conputation results
+    GpuMat grad, qangle, grad_buf, qangle_buf;
+
+	// returns subbuffer with required size, reallocates buffer if nessesary.
+	static GpuMat getBuffer(const Size& sz, int type, GpuMat& buf);
+	static GpuMat getBuffer(int rows, int cols, int type, GpuMat& buf);
+
+	std::vector<GpuMat> image_scales;
+};
+
+
+////////////////////////////////// BruteForceMatcher //////////////////////////////////
+
+class CV_EXPORTS BruteForceMatcher_GPU_base
+{
+public:
+    enum DistType {L1Dist = 0, L2Dist, HammingDist};
+
+    explicit BruteForceMatcher_GPU_base(DistType distType = L2Dist);
+
+    // Add descriptors to train descriptor collection
+    void add(const std::vector<GpuMat>& descCollection);
+
+    // Get train descriptors collection
+    const std::vector<GpuMat>& getTrainDescriptors() const;
+
+    // Clear train descriptors collection
+    void clear();
+
+    // Return true if there are not train descriptors in collection
+    bool empty() const;
+
+    // Return true if the matcher supports mask in match methods
+    bool isMaskSupported() const;
+
+    // Find one best match for each query descriptor
+    void matchSingle(const GpuMat& query, const GpuMat& train, 
+        GpuMat& trainIdx, GpuMat& distance, 
+        const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
+
+    // Download trainIdx and distance and convert it to CPU vector with DMatch
+    static void matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>& matches);
+    // Convert trainIdx and distance to vector with DMatch
+    static void matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches);
+
+    // Find one best match for each query descriptor
+    void match(const GpuMat& query, const GpuMat& train, std::vector<DMatch>& matches, const GpuMat& mask = GpuMat());
+
+    // Make gpu collection of trains and masks in suitable format for matchCollection function
+    void makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
+
+    // Find one best match from train collection for each query descriptor
+    void matchCollection(const GpuMat& query, const GpuMat& trainCollection, 
+        GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
+        const GpuMat& masks = GpuMat(), Stream& stream = Stream::Null());
+
+    // Download trainIdx, imgIdx and distance and convert it to vector with DMatch
+    static void matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>& matches);
+    // Convert trainIdx, imgIdx and distance to vector with DMatch
+    static void matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches);
+
+    // Find one best match from train collection for each query descriptor.
+    void match(const GpuMat& query, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
+
+    // Find k best matches for each query descriptor (in increasing order of distances)
+    void knnMatchSingle(const GpuMat& query, const GpuMat& train,
+        GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k,
+        const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
+
+    // Download trainIdx and distance and convert it to vector with DMatch
+    // compactResult is used when mask is not empty. If compactResult is false matches
+    // vector will have the same size as queryDescriptors rows. If compactResult is true
+    // matches vector will not contain matches for fully masked out query descriptors.
+    static void knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+    // Convert trainIdx and distance to vector with DMatch
+    static void knnMatchConvert(const Mat& trainIdx, const Mat& distance,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+
+    // Find k best matches for each query descriptor (in increasing order of distances).
+    // compactResult is used when mask is not empty. If compactResult is false matches
+    // vector will have the same size as queryDescriptors rows. If compactResult is true
+    // matches vector will not contain matches for fully masked out query descriptors.
+    void knnMatch(const GpuMat& query, const GpuMat& train,
+        std::vector< std::vector<DMatch> >& matches, int k, const GpuMat& mask = GpuMat(),
+        bool compactResult = false);
+
+    // Find k best matches from train collection for each query descriptor (in increasing order of distances)
+    void knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection,
+        GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
+        const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null());
+
+    // Download trainIdx and distance and convert it to vector with DMatch
+    // compactResult is used when mask is not empty. If compactResult is false matches
+    // vector will have the same size as queryDescriptors rows. If compactResult is true
+    // matches vector will not contain matches for fully masked out query descriptors.
+    static void knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+    // Convert trainIdx and distance to vector with DMatch
+    static void knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+
+    // Find k best matches  for each query descriptor (in increasing order of distances).
+    // compactResult is used when mask is not empty. If compactResult is false matches
+    // vector will have the same size as queryDescriptors rows. If compactResult is true
+    // matches vector will not contain matches for fully masked out query descriptors.
+    void knnMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, int k,
+        const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
+
+    // Find best matches for each query descriptor which have distance less than maxDistance.
+    // nMatches.at<int>(0, queryIdx) will contain matches count for queryIdx.
+    // carefully nMatches can be greater than trainIdx.cols - it means that matcher didn't find all matches,
+    // because it didn't have enough memory.
+    // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nTrain / 100), 10),
+    // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
+    // Matches doesn't sorted.
+    void radiusMatchSingle(const GpuMat& query, const GpuMat& train,
+        GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
+        const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
+
+    // Download trainIdx, nMatches and distance and convert it to vector with DMatch.
+    // matches will be sorted in increasing order of distances.
+    // compactResult is used when mask is not empty. If compactResult is false matches
+    // vector will have the same size as queryDescriptors rows. If compactResult is true
+    // matches vector will not contain matches for fully masked out query descriptors.
+    static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+    // Convert trainIdx, nMatches and distance to vector with DMatch.
+    static void radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+
+    // Find best matches for each query descriptor which have distance less than maxDistance
+    // in increasing order of distances).
+    void radiusMatch(const GpuMat& query, const GpuMat& train,
+        std::vector< std::vector<DMatch> >& matches, float maxDistance,
+        const GpuMat& mask = GpuMat(), bool compactResult = false);
+
+    // Find best matches for each query descriptor which have distance less than maxDistance.
+    // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nQuery / 100), 10),
+    // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
+    // Matches doesn't sorted.
+    void radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
+        const std::vector<GpuMat>& masks = std::vector<GpuMat>(), Stream& stream = Stream::Null());
+
+    // Download trainIdx, imgIdx, nMatches and distance and convert it to vector with DMatch.
+    // matches will be sorted in increasing order of distances.
+    // compactResult is used when mask is not empty. If compactResult is false matches
+    // vector will have the same size as queryDescriptors rows. If compactResult is true
+    // matches vector will not contain matches for fully masked out query descriptors.
+    static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+    // Convert trainIdx, nMatches and distance to vector with DMatch.
+    static void radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches,
+        std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+
+    // Find best matches from train collection for each query descriptor which have distance less than
+    // maxDistance (in increasing order of distances).
+    void radiusMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, float maxDistance,
+        const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
+
+    DistType distType;
+
+private:
+    std::vector<GpuMat> trainDescCollection;
+};
+
+template <class Distance>
+class CV_EXPORTS BruteForceMatcher_GPU;
+
+template <typename T>
+class CV_EXPORTS BruteForceMatcher_GPU< L1<T> > : public BruteForceMatcher_GPU_base
+{
+public:
+    explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(L1Dist) {}
+    explicit BruteForceMatcher_GPU(L1<T> /*d*/) : BruteForceMatcher_GPU_base(L1Dist) {}
+};
+template <typename T>
+class CV_EXPORTS BruteForceMatcher_GPU< L2<T> > : public BruteForceMatcher_GPU_base
+{
+public:
+    explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(L2Dist) {}
+    explicit BruteForceMatcher_GPU(L2<T> /*d*/) : BruteForceMatcher_GPU_base(L2Dist) {}
+};
+template <> class CV_EXPORTS BruteForceMatcher_GPU< Hamming > : public BruteForceMatcher_GPU_base
+{
+public:
+    explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(HammingDist) {}
+    explicit BruteForceMatcher_GPU(Hamming /*d*/) : BruteForceMatcher_GPU_base(HammingDist) {}
+};
+
+////////////////////////////////// CascadeClassifier_GPU //////////////////////////////////////////
+// The cascade classifier class for object detection.
+class CV_EXPORTS CascadeClassifier_GPU
+{
+public:
+    CascadeClassifier_GPU();
+    CascadeClassifier_GPU(const std::string& filename);
+    ~CascadeClassifier_GPU();
+
+    bool empty() const;
+    bool load(const std::string& filename);
+    void release();
+
+    /* returns number of detected objects */
+    int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size());
+
+    bool findLargestObject;
+    bool visualizeInPlace;
+
+    Size getClassifierSize() const;
+private:
+
+    struct CascadeClassifierImpl;
+    CascadeClassifierImpl* impl;
+};
+
+////////////////////////////////// SURF //////////////////////////////////////////
+
+class CV_EXPORTS SURF_GPU : public CvSURFParams
+{
+public:
+    enum KeypointLayout 
+    {
+        SF_X = 0,
+        SF_Y,
+        SF_LAPLACIAN,
+        SF_SIZE,
+        SF_DIR,
+        SF_HESSIAN,
+        SF_FEATURE_STRIDE
+    };
+
+    //! the default constructor
+    SURF_GPU();
+    //! the full constructor taking all the necessary parameters
+    explicit SURF_GPU(double _hessianThreshold, int _nOctaves=4,
+         int _nOctaveLayers=2, bool _extended=false, float _keypointsRatio=0.01f, bool _upright = false);
+
+    //! returns the descriptor size in float's (64 or 128)
+    int descriptorSize() const;
+
+    //! upload host keypoints to device memory
+    void uploadKeypoints(const vector<KeyPoint>& keypoints, GpuMat& keypointsGPU);
+    //! download keypoints from device to host memory
+    void downloadKeypoints(const GpuMat& keypointsGPU, vector<KeyPoint>& keypoints);
+
+    //! download descriptors from device to host memory
+    void downloadDescriptors(const GpuMat& descriptorsGPU, vector<float>& descriptors);
+    
+    //! finds the keypoints using fast hessian detector used in SURF
+    //! supports CV_8UC1 images
+    //! keypoints will have nFeature cols and 6 rows
+    //! keypoints.ptr<float>(SF_X)[i] will contain x coordinate of i'th feature
+    //! keypoints.ptr<float>(SF_Y)[i] will contain y coordinate of i'th feature
+    //! keypoints.ptr<float>(SF_LAPLACIAN)[i] will contain laplacian sign of i'th feature
+    //! keypoints.ptr<float>(SF_SIZE)[i] will contain size of i'th feature
+    //! keypoints.ptr<float>(SF_DIR)[i] will contain orientation of i'th feature
+    //! keypoints.ptr<float>(SF_HESSIAN)[i] will contain response of i'th feature
+    void operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints);
+    //! finds the keypoints and computes their descriptors. 
+    //! Optionally it can compute descriptors for the user-provided keypoints and recompute keypoints direction
+    void operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors, 
+        bool useProvidedKeypoints = false);
+
+    void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints);
+    void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, GpuMat& descriptors, 
+        bool useProvidedKeypoints = false);
+
+    void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, std::vector<float>& descriptors, 
+        bool useProvidedKeypoints = false);
+
+    void releaseMemory();
+
+    //! max keypoints = min(keypointsRatio * img.size().area(), 65535)
+    float keypointsRatio;
+
+    GpuMat sum, mask1, maskSum, intBuffer;
+
+    GpuMat det, trace;
+
+    GpuMat maxPosBuffer;
+};
+
+////////////////////////////////// Optical Flow //////////////////////////////////////////
+
+class CV_EXPORTS BroxOpticalFlow
+{
+public:
+    BroxOpticalFlow(float alpha_, float gamma_, float scale_factor_, int inner_iterations_, int outer_iterations_, int solver_iterations_) :
+        alpha(alpha_), gamma(gamma_), scale_factor(scale_factor_), 
+        inner_iterations(inner_iterations_), outer_iterations(outer_iterations_), solver_iterations(solver_iterations_)
+    {
+    }
+
+    //! Compute optical flow
+    //! frame0 - source frame (supports only CV_32FC1 type)
+    //! frame1 - frame to track (with the same size and type as frame0)
+    //! u      - flow horizontal component (along x axis)
+    //! v      - flow vertical component (along y axis)
+    void operator ()(const GpuMat& frame0, const GpuMat& frame1, GpuMat& u, GpuMat& v, Stream& stream = Stream::Null());
+
+    //! flow smoothness
+    float alpha;
+
+    //! gradient constancy importance
+    float gamma;
+
+    //! pyramid scale factor
+    float scale_factor;
+
+    //! number of lagged non-linearity iterations (inner loop)
+    int inner_iterations;
+
+    //! number of warping iterations (number of pyramid levels)
+    int outer_iterations;
+
+    //! number of linear system solver iterations
+    int solver_iterations;
+
+    GpuMat 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)
+//! fu       - forward horizontal displacement
+//! fv       - forward vertical displacement
+//! bu       - backward horizontal displacement
+//! bv       - backward vertical displacement
+//! pos      - new frame position
+//! newFrame - new frame
+//! buf      - temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 GpuMat;
+//!            occlusion masks            0, occlusion masks            1,
+//!            interpolated forward flow  0, interpolated forward flow  1,
+//!            interpolated backward flow 0, interpolated backward flow 1
+//!            
+CV_EXPORTS void interpolateFrames(const GpuMat& frame0, const GpuMat& frame1, 
+                                  const GpuMat& fu, const GpuMat& fv,
+                                  const GpuMat& bu, const GpuMat& bv, 
+                                  float pos, GpuMat& newFrame, GpuMat& buf,
+                                  Stream& stream = Stream::Null());
+
+} // namespace gpu
+
+//! Speckle filtering - filters small connected components on diparity image.
+//! It sets pixel (x,y) to newVal if it coresponds to small CC with size < maxSpeckleSize.
+//! Threshold for border between CC is diffThreshold;
+CV_EXPORTS void filterSpeckles(Mat& img, uchar newVal, int maxSpeckleSize, uchar diffThreshold, Mat& buf);
+
+} // namespace cv
 
 #endif /* __OPENCV_GPU_HPP__ */
diff --git a/modules/gpu/include/opencv2/gpu/gpumat.hpp b/modules/gpu/include/opencv2/gpu/gpumat.hpp
index e36a94a17ae14fc77681b5e08c3384257214eafd..3baff61281050f6fa9611bef8ec77c9359e9eb52 100644
--- a/modules/gpu/include/opencv2/gpu/gpumat.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpumat.hpp
@@ -40,427 +40,4 @@
 //
 //M*/
 
-#ifndef __OPENCV_GPUMAT_HPP__
-#define __OPENCV_GPUMAT_HPP__
-
-#include "opencv2/core/core.hpp"
-#include "opencv2/gpu/devmem2d.hpp"
-
-namespace cv { namespace gpu
-{
-    //! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
-    class CV_EXPORTS GpuMat
-    {
-    public:
-        //! returns lightweight DevMem2D_ structure for passing to nvcc-compiled code.
-        // Contains just image size, data ptr and step.
-        template <class T> operator DevMem2D_<T>() const;
-        template <class T> operator PtrStep_<T>() const;
-		template <class T> operator PtrStep<T>() const;
-
-
-
-
-
-        //! builds GpuMat from Mat. Perfom blocking upload to device.
-        explicit GpuMat(const Mat& m);
-
-        //! pefroms blocking upload data to GpuMat.
-        void upload(const Mat& m);
-
-        //! downloads data from device to host memory. Blocking calls.
-        void download(Mat& m) const;
-        operator Mat() const
-        {
-            Mat m;
-            download(m);
-            return m;
-        }
-
-
-
-
-
-
-        //! default constructor
-        GpuMat();
-
-        //! constructs GpuMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
-        GpuMat(int rows, int cols, int type);
-        GpuMat(Size size, int type);
-
-        //! constucts GpuMatrix and fills it with the specified value _s.
-        GpuMat(int rows, int cols, int type, const Scalar& s);
-        GpuMat(Size size, int type, const Scalar& s);
-
-        //! copy constructor
-        GpuMat(const GpuMat& m);
-
-        //! constructor for GpuMatrix headers pointing to user-allocated data
-        GpuMat(int rows, int cols, int type, void* data, size_t step = Mat::AUTO_STEP);
-        GpuMat(Size size, int type, void* data, size_t step = Mat::AUTO_STEP);
-
-        //! creates a matrix header for a part of the bigger matrix
-        GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange);
-        GpuMat(const GpuMat& m, const Rect& roi);
-
-        //! destructor - calls release()
-        ~GpuMat();
-
-        //! assignment operators
-        GpuMat& operator = (const GpuMat& m);
-
-        //! returns a new GpuMatrix header for the specified row
-        GpuMat row(int y) const;
-        //! returns a new GpuMatrix header for the specified column
-        GpuMat col(int x) const;
-        //! ... for the specified row span
-        GpuMat rowRange(int startrow, int endrow) const;
-        GpuMat rowRange(const Range& r) const;
-        //! ... for the specified column span
-        GpuMat colRange(int startcol, int endcol) const;
-        GpuMat colRange(const Range& r) const;
-
-        //! returns deep copy of the GpuMatrix, i.e. the data is copied
-        GpuMat clone() const;
-        //! copies the GpuMatrix content to "m".
-        // It calls m.create(this->size(), this->type()).
-        void copyTo(GpuMat& m) const;
-        //! copies those GpuMatrix elements to "m" that are marked with non-zero mask elements.
-        void copyTo(GpuMat& m, const GpuMat& mask) const;
-        //! converts GpuMatrix to another datatype with optional scalng. See cvConvertScale.
-        void convertTo(GpuMat& m, int rtype, double alpha = 1, double beta = 0) const;
-
-        void assignTo(GpuMat& m, int type=-1) const;
-
-        //! sets every GpuMatrix element to s
-        GpuMat& operator = (const Scalar& s);
-        //! sets some of the GpuMatrix elements to s, according to the mask
-        GpuMat& setTo(const Scalar& s, const GpuMat& mask = GpuMat());
-        //! creates alternative GpuMatrix header for the same data, with different
-        // number of channels and/or different number of rows. see cvReshape.
-        GpuMat reshape(int cn, int rows = 0) const;
-
-        //! allocates new GpuMatrix data unless the GpuMatrix already has specified size and type.
-        // previous data is unreferenced if needed.
-        void create(int rows, int cols, int type);
-        void create(Size size, int type);
-        //! decreases reference counter;
-        // deallocate the data when reference counter reaches 0.
-        void release();
-
-        //! swaps with other smart pointer
-        void swap(GpuMat& mat);
-
-        //! locates GpuMatrix header within a parent GpuMatrix. See below
-        void locateROI(Size& wholeSize, Point& ofs) const;
-        //! moves/resizes the current GpuMatrix ROI inside the parent GpuMatrix.
-        GpuMat& adjustROI(int dtop, int dbottom, int dleft, int dright);
-        //! extracts a rectangular sub-GpuMatrix
-        // (this is a generalized form of row, rowRange etc.)
-        GpuMat operator()(Range rowRange, Range colRange) const;
-        GpuMat operator()(const Rect& roi) const;
-
-        //! returns true iff the GpuMatrix data is continuous
-        // (i.e. when there are no gaps between successive rows).
-        // similar to CV_IS_GpuMat_CONT(cvGpuMat->type)
-        bool isContinuous() const;
-        //! returns element size in bytes,
-        // similar to CV_ELEM_SIZE(cvMat->type)
-        size_t elemSize() const;
-        //! returns the size of element channel in bytes.
-        size_t elemSize1() const;
-        //! returns element type, similar to CV_MAT_TYPE(cvMat->type)
-        int type() const;
-        //! returns element type, similar to CV_MAT_DEPTH(cvMat->type)
-        int depth() const;
-        //! returns element type, similar to CV_MAT_CN(cvMat->type)
-        int channels() const;
-        //! returns step/elemSize1()
-        size_t step1() const;
-        //! returns GpuMatrix size:
-        // width == number of columns, height == number of rows
-        Size size() const;
-        //! returns true if GpuMatrix data is NULL
-        bool empty() const;
-
-        //! returns pointer to y-th row
-        uchar* ptr(int y = 0);
-        const uchar* ptr(int y = 0) const;
-
-        //! template version of the above method
-        template<typename _Tp> _Tp* ptr(int y = 0);
-        template<typename _Tp> const _Tp* ptr(int y = 0) const;
-
-        /*! includes several bit-fields:
-        - the magic signature
-        - continuity flag
-        - depth
-        - number of channels
-        */
-        int flags;
-
-        //! the number of rows and columns
-        int rows, cols;
-
-        //! a distance between successive rows in bytes; includes the gap if any
-        size_t step;
-
-        //! pointer to the data
-        uchar* data;
-
-        //! pointer to the reference counter;
-        // when GpuMatrix points to user-allocated data, the pointer is NULL
-        int* refcount;
-
-        //! helper fields used in locateROI and adjustROI
-        uchar* datastart;
-        uchar* dataend;
-    };
-
-    //! Creates continuous GPU matrix
-    CV_EXPORTS void createContinuous(int rows, int cols, int type, GpuMat& m);
-    CV_EXPORTS GpuMat createContinuous(int rows, int cols, int type);
-    CV_EXPORTS void createContinuous(Size size, int type, GpuMat& m);
-    CV_EXPORTS GpuMat createContinuous(Size size, int type);
-
-    //! Ensures that size of the given matrix is not less than (rows, cols) size
-    //! and matrix type is match specified one too
-    CV_EXPORTS void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m);
-    CV_EXPORTS void ensureSizeIsEnough(Size size, int type, GpuMat& m);
-
-    ////////////////////////////////////////////////////////////////////////
-
-    template <class T> inline GpuMat::operator DevMem2D_<T>() const { return DevMem2D_<T>(rows, cols, (T*)data, step); }
-    template <class T> inline GpuMat::operator PtrStep_<T>() const { return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this)); }
-	template <class T> inline GpuMat::operator PtrStep<T>() const { return PtrStep<T>((T*)data, step); }	
-
-
-
-
-
-
-    inline GpuMat::GpuMat() 
-        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) 
-    {
-    }
-
-    inline GpuMat::GpuMat(int rows_, int cols_, int type_) 
-        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-    {
-        if (rows_ > 0 && cols_ > 0)
-            create(rows_, cols_, type_);
-    }
-
-    inline GpuMat::GpuMat(Size size_, int type_) 
-        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-    {
-        if (size_.height > 0 && size_.width > 0)
-            create(size_.height, size_.width, type_);
-    }
-
-    inline GpuMat::GpuMat(int rows_, int cols_, int type_, const Scalar& s_) 
-        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-    {
-        if (rows_ > 0 && cols_ > 0)
-        {
-            create(rows_, cols_, type_);
-            setTo(s_);
-        }
-    }
-
-    inline GpuMat::GpuMat(Size size_, int type_, const Scalar& s_) 
-        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-    {
-        if (size_.height > 0 && size_.width > 0)
-        {
-            create(size_.height, size_.width, type_);
-            setTo(s_);
-        }
-    }
-
-    inline GpuMat::~GpuMat() 
-    { 
-        release(); 
-    }
-
-    inline GpuMat GpuMat::clone() const
-    {
-        GpuMat m;
-        copyTo(m);
-        return m;
-    }
-
-    inline void GpuMat::assignTo(GpuMat& m, int type) const
-    {
-        if (type < 0)
-            m = *this;
-        else
-            convertTo(m, type);
-    }
-
-    inline size_t GpuMat::step1() const 
-    { 
-        return step / elemSize1(); 
-    }
-
-    inline bool GpuMat::empty() const 
-    { 
-        return data == 0; 
-    }
-
-    template<typename _Tp> inline _Tp* GpuMat::ptr(int y)
-    {
-        return (_Tp*)ptr(y);
-    }
-
-    template<typename _Tp> inline const _Tp* GpuMat::ptr(int y) const
-    {
-        return (const _Tp*)ptr(y);
-    }
-
-    inline void swap(GpuMat& a, GpuMat& b) 
-    { 
-        a.swap(b); 
-    }
-
-    inline GpuMat GpuMat::row(int y) const 
-    { 
-        return GpuMat(*this, Range(y, y+1), Range::all()); 
-    }
-
-    inline GpuMat GpuMat::col(int x) const 
-    { 
-        return GpuMat(*this, Range::all(), Range(x, x+1)); 
-    }
-
-    inline GpuMat GpuMat::rowRange(int startrow, int endrow) const 
-    { 
-        return GpuMat(*this, Range(startrow, endrow), Range::all()); 
-    }
-
-    inline GpuMat GpuMat::rowRange(const Range& r) const 
-    { 
-        return GpuMat(*this, r, Range::all()); 
-    }
-
-    inline GpuMat GpuMat::colRange(int startcol, int endcol) const 
-    { 
-        return GpuMat(*this, Range::all(), Range(startcol, endcol)); 
-    }
-
-    inline GpuMat GpuMat::colRange(const Range& r) const 
-    { 
-        return GpuMat(*this, Range::all(), r); 
-    }
-
-    inline void GpuMat::create(Size size_, int type_) 
-    { 
-        create(size_.height, size_.width, type_); 
-    }
-
-    inline GpuMat GpuMat::operator()(Range rowRange, Range colRange) const 
-    { 
-        return GpuMat(*this, rowRange, colRange); 
-    }
-
-    inline GpuMat GpuMat::operator()(const Rect& roi) const 
-    { 
-        return GpuMat(*this, roi); 
-    }
-
-    inline bool GpuMat::isContinuous() const 
-    { 
-        return (flags & Mat::CONTINUOUS_FLAG) != 0; 
-    }
-
-    inline size_t GpuMat::elemSize() const 
-    { 
-        return CV_ELEM_SIZE(flags); 
-    }
-
-    inline size_t GpuMat::elemSize1() const 
-    { 
-        return CV_ELEM_SIZE1(flags); 
-    }
-
-    inline int GpuMat::type() const 
-    { 
-        return CV_MAT_TYPE(flags); 
-    }
-
-    inline int GpuMat::depth() const 
-    { 
-        return CV_MAT_DEPTH(flags); 
-    }
-
-    inline int GpuMat::channels() const 
-    { 
-        return CV_MAT_CN(flags); 
-    }
-
-    inline Size GpuMat::size() const 
-    { 
-        return Size(cols, rows); 
-    }
-
-    inline unsigned char* GpuMat::ptr(int y)
-    {
-        CV_DbgAssert((unsigned)y < (unsigned)rows);
-        return data + step * y;
-    }
-
-    inline const unsigned char* GpuMat::ptr(int y) const
-    {
-        CV_DbgAssert((unsigned)y < (unsigned)rows);
-        return data + step * y;
-    }
-
-    inline GpuMat& GpuMat::operator = (const Scalar& s)
-    {
-        setTo(s);
-        return *this;
-    }
-
-    inline GpuMat createContinuous(int rows, int cols, int type)
-    {
-        GpuMat m;
-        createContinuous(rows, cols, type, m);
-        return m;
-    }
-
-    inline void createContinuous(Size size, int type, GpuMat& m)
-    {
-        createContinuous(size.height, size.width, type, m);
-    }
-
-    inline GpuMat createContinuous(Size size, int type)
-    {
-        GpuMat m;
-        createContinuous(size, type, m);
-        return m;
-    }
-
-    inline void ensureSizeIsEnough(Size size, int type, GpuMat& m)
-    {
-        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)
-            m.create(1, area, type);
-        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);
-    }
-}}
-
-#endif // __OPENCV_GPUMAT_HPP__
+#include "opencv2/core/gpumat.hpp"
diff --git a/modules/gpu/include/opencv2/gpu/matrix_operations.hpp b/modules/gpu/include/opencv2/gpu/matrix_operations.hpp
deleted file mode 100644
index 5a6b1bbfc41c3a327078cbaacc49412bd3de9cbb..0000000000000000000000000000000000000000
--- a/modules/gpu/include/opencv2/gpu/matrix_operations.hpp
+++ /dev/null
@@ -1,142 +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 GpuMaterials 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_MATRIX_OPERATIONS_HPP__
-#define __OPENCV_GPU_MATRIX_OPERATIONS_HPP__
-
-namespace cv
-{
-
-namespace gpu
-{
-///////////////////////////////////////////////////////////////////////
-//////////////////////////////// CudaMem ////////////////////////////////
-///////////////////////////////////////////////////////////////////////
-
-inline CudaMem::CudaMem()  : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0) {}
-inline CudaMem::CudaMem(int _rows, int _cols, int _type, int _alloc_type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
-{
-    if( _rows > 0 && _cols > 0 )
-        create( _rows, _cols, _type, _alloc_type);
-}
-
-inline CudaMem::CudaMem(Size _size, int _type, int _alloc_type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
-{
-    if( _size.height > 0 && _size.width > 0 )
-        create( _size.height, _size.width, _type, _alloc_type);
-}
-
-inline CudaMem::CudaMem(const CudaMem& m) : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend), alloc_type(m.alloc_type)
-{
-    if( refcount )
-        CV_XADD(refcount, 1);
-}
-
-inline CudaMem::CudaMem(const Mat& m, int _alloc_type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
-{
-    if( m.rows > 0 && m.cols > 0 )
-        create( m.size(), m.type(), _alloc_type);
-
-    Mat tmp = createMatHeader();
-    m.copyTo(tmp);
-}
-
-inline CudaMem::~CudaMem()
-{
-    release();
-
-}
-
-inline CudaMem& CudaMem::operator = (const CudaMem& m)
-{
-    if( this != &m )
-    {
-        if( m.refcount )
-            CV_XADD(m.refcount, 1);
-        release();
-        flags = m.flags;
-        rows = m.rows; cols = m.cols;
-        step = m.step; data = m.data;
-        datastart = m.datastart;
-        dataend = m.dataend;
-        refcount = m.refcount;
-        alloc_type = m.alloc_type;
-    }
-    return *this;
-}
-
-inline CudaMem CudaMem::clone() const
-{
-    CudaMem m(size(), type(), alloc_type);
-    Mat to = m;
-    Mat from = *this;
-    from.copyTo(to);
-    return m;
-}
-
-inline void CudaMem::create(Size _size, int _type, int _alloc_type) { create(_size.height, _size.width, _type, _alloc_type); }
-
-
-//CCP void CudaMem::create(int _rows, int _cols, int _type, int _alloc_type);
-//CPP void CudaMem::release();
-
-inline Mat CudaMem::createMatHeader() const { return Mat(size(), type(), data, step); }
-inline CudaMem::operator Mat() const { return createMatHeader(); }
-
-inline CudaMem::operator GpuMat() const { return createGpuMatHeader(); }
-//CPP GpuMat CudaMem::createGpuMatHeader() const;
-
-inline bool CudaMem::isContinuous() const { return (flags & Mat::CONTINUOUS_FLAG) != 0; }
-inline size_t CudaMem::elemSize() const { return CV_ELEM_SIZE(flags); }
-inline size_t CudaMem::elemSize1() const { return CV_ELEM_SIZE1(flags); }
-inline int CudaMem::type() const { return CV_MAT_TYPE(flags); }
-inline int CudaMem::depth() const { return CV_MAT_DEPTH(flags); }
-inline int CudaMem::channels() const { return CV_MAT_CN(flags); }
-inline size_t CudaMem::step1() const { return step/elemSize1(); }
-inline Size CudaMem::size() const { return Size(cols, rows); }
-inline bool CudaMem::empty() const { return data == 0; }
-
-} /* end of namespace gpu */
-
-} /* end of namespace cv */
-
-#endif /* __OPENCV_GPU_MATRIX_OPERATIONS_HPP__ */
diff --git a/modules/gpu/perf/perf_arithm.cpp b/modules/gpu/perf/perf_arithm.cpp
index 8e34023bb6fa2bbf481845c1800f2a02b6b5435e..d740388ffca81140e828652ca861882b26321fce 100644
--- a/modules/gpu/perf/perf_arithm.cpp
+++ b/modules/gpu/perf/perf_arithm.cpp
@@ -24,7 +24,7 @@ PERF_TEST_P(DevInfo_Size_MatType, transpose, testing::Combine(testing::ValuesIn(
         transpose(src, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -55,7 +55,7 @@ PERF_TEST_P(DevInfo_Size_MatType_FlipCode, flip, testing::Combine(testing::Value
         flip(src, dst, flipCode);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -85,7 +85,7 @@ PERF_TEST_P(DevInfo_Size_MatType, LUT, testing::Combine(testing::ValuesIn(device
         LUT(src, lut, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -115,8 +115,8 @@ PERF_TEST_P(DevInfo_Size, cartToPolar, testing::Combine(testing::ValuesIn(device
         cartToPolar(x, y, magnitude, angle);
     }
 
-    Mat magnitude_host = magnitude;
-    Mat angle_host = angle;
+    Mat magnitude_host(magnitude);
+    Mat angle_host(angle);
 
     SANITY_CHECK(magnitude_host);
     SANITY_CHECK(angle_host);
@@ -147,8 +147,8 @@ PERF_TEST_P(DevInfo_Size, polarToCart, testing::Combine(testing::ValuesIn(device
         polarToCart(magnitude, angle, x, y);
     }
 
-    Mat x_host = x;
-    Mat y_host = angle;
+    Mat x_host(x);
+    Mat y_host(y);
 
     SANITY_CHECK(x_host);
     SANITY_CHECK(y_host);
@@ -180,7 +180,7 @@ PERF_TEST_P(DevInfo_Size_MatType, addMat, testing::Combine(testing::ValuesIn(dev
         add(a, b, c);
     }
 
-    Mat c_host = c;
+    Mat c_host(c);
 
     SANITY_CHECK(c_host);
 }
@@ -210,7 +210,7 @@ PERF_TEST_P(DevInfo_Size_MatType, addScalar, testing::Combine(testing::ValuesIn(
         add(a, b, c);
     }
 
-    Mat c_host = c;
+    Mat c_host(c);
 
     SANITY_CHECK(c_host);
 }
@@ -241,7 +241,7 @@ PERF_TEST_P(DevInfo_Size_MatType, subtractMat, testing::Combine(testing::ValuesI
         subtract(a, b, c);
     }
 
-    Mat c_host = c;
+    Mat c_host(c);
 
     SANITY_CHECK(c_host);
 }
@@ -270,7 +270,7 @@ PERF_TEST_P(DevInfo_Size, multiplyMat, testing::Combine(testing::ValuesIn(device
         multiply(a, b, c);
     }
 
-    Mat c_host = c;
+    Mat c_host(c);
 
     SANITY_CHECK(c_host);
 }
@@ -300,7 +300,7 @@ PERF_TEST_P(DevInfo_Size_MatType, multiplyScalar, testing::Combine(testing::Valu
         multiply(a, b, c);
     }
 
-    Mat c_host = c;
+    Mat c_host(c);
 
     SANITY_CHECK(c_host);
 }
@@ -327,7 +327,7 @@ PERF_TEST_P(DevInfo_Size, exp, testing::Combine(testing::ValuesIn(devices()),
         exp(a, b);
     }
 
-    Mat b_host = b;
+    Mat b_host(b);
 
     SANITY_CHECK(b_host);
 }
@@ -356,7 +356,7 @@ PERF_TEST_P(DevInfo_Size_MatType, pow, testing::Combine(testing::ValuesIn(device
         pow(src, 2.0, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -389,7 +389,7 @@ PERF_TEST_P(DevInfo_Size_MatType_CmpOp, compare, testing::Combine(testing::Value
         compare(src1, src2, dst, cmpop);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -418,7 +418,7 @@ PERF_TEST_P(DevInfo_Size_MatType, bitwise_not, testing::Combine(testing::ValuesI
         bitwise_not(src, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -449,7 +449,7 @@ PERF_TEST_P(DevInfo_Size_MatType, bitwise_and, testing::Combine(testing::ValuesI
         bitwise_and(src1, src2, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -480,7 +480,7 @@ PERF_TEST_P(DevInfo_Size_MatType, min, testing::Combine(testing::ValuesIn(device
         min(src1, src2, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -712,7 +712,7 @@ PERF_TEST_P(DevInfo_Size_MatType, addWeighted, testing::Combine(testing::ValuesI
         addWeighted(src1, 0.5, src2, 0.5, 0.0, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -743,7 +743,7 @@ PERF_TEST_P(DevInfo_Size_MatType_FlipCode, reduce, testing::Combine(testing::Val
         reduce(src, dst, dim, CV_REDUCE_MIN);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -774,7 +774,7 @@ PERF_TEST_P(DevInfo_Size, gemm, testing::Combine(testing::ValuesIn(devices()),
         gemm(src1, src2, 1.0, src3, 1.0, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp
index e84f87b3bace17768e7ecc95d566620f0e6d1f41..4ac922e99bc0b57589a77ccb7d942fd9707d804d 100644
--- a/modules/gpu/perf/perf_calib3d.cpp
+++ b/modules/gpu/perf/perf_calib3d.cpp
@@ -20,7 +20,7 @@ PERF_TEST_P(DevInfo, transformPoints, testing::ValuesIn(devices()))
         transformPoints(src, Mat::ones(1, 3, CV_32FC1), Mat::ones(1, 3, CV_32FC1), dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -45,7 +45,7 @@ PERF_TEST_P(DevInfo, projectPoints, testing::ValuesIn(devices()))
         projectPoints(src, Mat::ones(1, 3, CV_32FC1), Mat::ones(1, 3, CV_32FC1), Mat::ones(3, 3, CV_32FC1), Mat(), dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp
index 55125f31bf78243998b77a04a0d8d82d9af2a1f4..da813bff624bdfea869629385579877ef9929a04 100644
--- a/modules/gpu/perf/perf_filters.cpp
+++ b/modules/gpu/perf/perf_filters.cpp
@@ -28,7 +28,7 @@ PERF_TEST_P(DevInfo_Size_MatType_KernelSize, boxFilter, testing::Combine(testing
         filter->apply(src, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -63,7 +63,7 @@ PERF_TEST_P(DevInfo_Size_MatType_MorphOp_KernelSize, morphologyFilter, testing::
         filter->apply(src, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -96,7 +96,7 @@ PERF_TEST_P(DevInfo_Size_MatType_KernelSize, linearFilter, testing::Combine(test
         filter->apply(src, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -130,7 +130,7 @@ PERF_TEST_P(DevInfo_Size_MatType_KernelSize, separableLinearFilter, testing::Com
         filter->apply(src, dst, Rect(0, 0, src.cols, src.rows));
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 3f7264125e1a8a94b0aa5c9b1855c6f397333555..7b8ffe4d46d4bc67ad959b040e4fdcbc107fde13 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -36,7 +36,7 @@ PERF_TEST_P(DevInfo_Size_MatType_Interpolation_BorderMode, remap, testing::Combi
         remap(src, dst, xmap, ymap, interpolation, borderMode);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -63,7 +63,7 @@ PERF_TEST_P(DevInfo, meanShiftFiltering, testing::ValuesIn(devices()))
         meanShiftFiltering(src, dst, 50, 50);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -91,8 +91,8 @@ PERF_TEST_P(DevInfo, meanShiftProc, testing::ValuesIn(devices()))
         meanShiftProc(src, dstr, dstsp, 50, 50);
     }
 
-    Mat dstr_host = dstr;
-    Mat dstsp_host = dstsp;
+    Mat dstr_host(dstr);
+    Mat dstsp_host(dstsp);
 
     SANITY_CHECK(dstr_host);
     SANITY_CHECK(dstsp_host);
diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp
index d1505f5611a6896b46334fb25de56345cf4dd226..ba66a0c6c070124c80dab48e0b798e68a85e9c24 100644
--- a/modules/gpu/perf/perf_matop.cpp
+++ b/modules/gpu/perf/perf_matop.cpp
@@ -25,7 +25,7 @@ PERF_TEST_P(DevInfo_Size_MatType, merge, testing::Combine(testing::ValuesIn(devi
         merge(src, dst);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -82,7 +82,7 @@ PERF_TEST_P(DevInfo_Size_MatType, setTo, testing::Combine(testing::ValuesIn(devi
         src.setTo(val);
     }
 
-    Mat src_host = src;
+    Mat src_host(src);
 
     SANITY_CHECK(src_host);
 }
@@ -115,7 +115,7 @@ PERF_TEST_P(DevInfo_Size_MatType, setToMasked, testing::Combine(testing::ValuesI
         src.setTo(val, mask);
     }
 
-    src_host = src;
+    src.download(src_host);
 
     SANITY_CHECK(src_host);
 }
@@ -148,7 +148,7 @@ PERF_TEST_P(DevInfo_Size_MatType, copyToMasked, testing::Combine(testing::Values
         src.copyTo(dst, mask);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
@@ -182,7 +182,7 @@ PERF_TEST_P(DevInfo_Size_MatType_MatType, convertTo, testing::Combine(testing::V
         src.convertTo(dst, type2, a, b);
     }
 
-    Mat dst_host = dst;
+    Mat dst_host(dst);
 
     SANITY_CHECK(dst_host);
 }
diff --git a/modules/gpu/src/arithm.cpp b/modules/gpu/src/arithm.cpp
index fabb3dfbc7d87f7ead684a544ef92670cd0888eb..a47d222910094bcc590a577ece2032630ae007cc 100644
--- a/modules/gpu/src/arithm.cpp
+++ b/modules/gpu/src/arithm.cpp
@@ -425,16 +425,22 @@ void cv::gpu::magnitudeSqr(const GpuMat& src, GpuMat& dst, Stream& stream)
 ////////////////////////////////////////////////////////////////////////
 // Polar <-> Cart
 
-namespace cv { namespace gpu { namespace mathfunc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace mathfunc 
 {
-    void cartToPolar_gpu(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, bool magSqr, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream);
-    void polarToCart_gpu(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream);
-}}}
+    void cartToPolar_gpu(DevMem2Df x, DevMem2Df y, DevMem2Df mag, bool magSqr, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream);
+    void polarToCart_gpu(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
     inline void cartToPolar_caller(const GpuMat& x, const GpuMat& y, GpuMat* mag, bool magSqr, GpuMat* angle, bool angleInDegrees, cudaStream_t stream)
     {
+        using namespace OPENCV_DEVICE_NAMESPACE_ mathfunc;
+
         CV_DbgAssert(x.size() == y.size() && x.type() == y.type());
         CV_Assert(x.depth() == CV_32F);
 
@@ -448,11 +454,13 @@ namespace
         GpuMat mag1cn = mag ? mag->reshape(1) : GpuMat();
         GpuMat angle1cn = angle ? angle->reshape(1) : GpuMat();
 
-        mathfunc::cartToPolar_gpu(x1cn, y1cn, mag1cn, magSqr, angle1cn, angleInDegrees, stream);
+        cartToPolar_gpu(x1cn, y1cn, mag1cn, magSqr, angle1cn, angleInDegrees, stream);
     }
 
     inline void polarToCart_caller(const GpuMat& mag, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, cudaStream_t stream)
     {
+        using namespace OPENCV_DEVICE_NAMESPACE_ mathfunc;
+
         CV_DbgAssert((mag.empty() || mag.size() == angle.size()) && mag.type() == angle.type());
         CV_Assert(mag.depth() == CV_32F);
 
@@ -464,34 +472,33 @@ namespace
         GpuMat x1cn = x.reshape(1);
         GpuMat y1cn = y.reshape(1);
 
-        mathfunc::polarToCart_gpu(mag1cn, angle1cn, x1cn, y1cn, angleInDegrees, stream);
+        polarToCart_gpu(mag1cn, angle1cn, x1cn, y1cn, angleInDegrees, stream);
     }
 }
 
 void cv::gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& dst, Stream& stream)
 {
-    ::cartToPolar_caller(x, y, &dst, false, 0, false, StreamAccessor::getStream(stream));
+    cartToPolar_caller(x, y, &dst, false, 0, false, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& dst, Stream& stream)
 {
-    ::cartToPolar_caller(x, y, &dst, true, 0, false, StreamAccessor::getStream(stream));
+    cartToPolar_caller(x, y, &dst, true, 0, false, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, Stream& stream)
 {
-    ::cartToPolar_caller(x, y, 0, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
+    cartToPolar_caller(x, y, 0, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& mag, GpuMat& angle, bool angleInDegrees, Stream& stream)
 {
-    ::cartToPolar_caller(x, y, &mag, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
+    cartToPolar_caller(x, y, &mag, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, Stream& stream)
 {
-    ::polarToCart_caller(magnitude, angle, x, y, angleInDegrees, StreamAccessor::getStream(stream));
+    polarToCart_caller(magnitude, angle, x, y, angleInDegrees, StreamAccessor::getStream(stream));
 }
 
-
 #endif /* !defined (HAVE_CUDA) */
diff --git a/modules/gpu/src/bilateral_filter.cpp b/modules/gpu/src/bilateral_filter.cpp
index bc2bec24a084fda927e5571c221e4e6a93d82525..12c159a483ed6413e3a0b4bd89f5a90b2b11a7b9 100644
--- a/modules/gpu/src/bilateral_filter.cpp
+++ b/modules/gpu/src/bilateral_filter.cpp
@@ -55,13 +55,19 @@ void cv::gpu::DisparityBilateralFilter::operator()(const GpuMat&, const GpuMat&,
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace bf 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace bilateral_filter
 {
-    void load_constants(float* table_color, const DevMem2Df& table_space, int ndisp, int radius, short edge_disc, short max_disc);
+    void load_constants(float* table_color, DevMem2Df table_space, int ndisp, int radius, short edge_disc, short max_disc);
+
+    void bilateral_filter_gpu(DevMem2Db disp, DevMem2Db img, int channels, int iters, cudaStream_t stream);
+    void bilateral_filter_gpu(DevMem2D_<short> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
-    void bilateral_filter_gpu(const DevMem2Db& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream);
-    void bilateral_filter_gpu(const DevMem2D_<short>& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream);
-}}}
+using namespace OPENCV_DEVICE_NAMESPACE_ bilateral_filter;
 
 namespace
 {
@@ -105,7 +111,7 @@ namespace
         short edge_disc = max<short>(short(1), short(ndisp * edge_threshold + 0.5));
         short max_disc = short(ndisp * max_disc_threshold + 0.5);
 
-        bf::load_constants(table_color.ptr<float>(), table_space, ndisp, radius, edge_disc, max_disc);
+        load_constants(table_color.ptr<float>(), table_space, ndisp, radius, edge_disc, max_disc);
 
         if (&dst != &disp)
         {
@@ -115,7 +121,7 @@ namespace
                 disp.copyTo(dst);
         }
 
-        bf::bilateral_filter_gpu((DevMem2D_<T>)dst, img, img.channels(), iters, StreamAccessor::getStream(stream));
+        bilateral_filter_gpu((DevMem2D_<T>)dst, img, img.channels(), iters, StreamAccessor::getStream(stream));
     }
 
     typedef void (*bilateral_filter_operator_t)(int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, 
diff --git a/modules/gpu/src/blend.cpp b/modules/gpu/src/blend.cpp
index 54345f616330135ac4039641e39eb1e7bb5a6571..4c4afc5c71cd643cc8d54bd4d98754dcda287079 100644
--- a/modules/gpu/src/blend.cpp
+++ b/modules/gpu/src/blend.cpp
@@ -52,15 +52,19 @@ void cv::gpu::blendLinear(const GpuMat&, const GpuMat&, const GpuMat&, const Gpu
 
 #else
 
-namespace cv { namespace gpu 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace blend
 {
     template <typename T>
-    void blendLinearCaller(int rows, int cols, int cn, const PtrStep<T>& img1, const PtrStep<T>& img2, 
-                           const PtrStepf& weights1, const PtrStepf& weights2, PtrStep<T> result, cudaStream_t stream);
+    void blendLinearCaller(int rows, int cols, int cn, PtrStep<T> img1, PtrStep<T> img2, PtrStepf weights1, PtrStepf weights2, PtrStep<T> result, cudaStream_t stream);
+
+    void blendLinearCaller8UC4(int rows, int cols, PtrStepb img1, PtrStepb img2, PtrStepf weights1, PtrStepf weights2, PtrStepb result, cudaStream_t stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
-    void blendLinearCaller8UC4(int rows, int cols, const PtrStepb& img1, const PtrStepb& img2, 
-                               const PtrStepf& weights1, const PtrStepf& weights2, PtrStepb result, cudaStream_t stream);
-}}
+using namespace OPENCV_DEVICE_NAMESPACE_ blend;
 
 void cv::gpu::blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
                           GpuMat& result, Stream& stream)
diff --git a/modules/gpu/src/brute_force_matcher.cpp b/modules/gpu/src/brute_force_matcher.cpp
index 4f9bd5cd720986f08592f3b5457ee153734a8c44..1d9314603880f553e95309143b02df1f7999c6bd 100644
--- a/modules/gpu/src/brute_force_matcher.cpp
+++ b/modules/gpu/src/brute_force_matcher.cpp
@@ -82,7 +82,9 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat&, vector< vec
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace bf_match
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace bf_match
 {
     template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
         const DevMem2Di& trainIdx, const DevMem2Df& distance, 
@@ -103,9 +105,9 @@ namespace cv { namespace gpu { namespace bf_match
     template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
         const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance,
         int cc, cudaStream_t stream);
-}}}
+}
 
-namespace cv { namespace gpu { namespace bf_knnmatch
+namespace bf_knnmatch
 {
     template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask, 
         const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
@@ -126,9 +128,9 @@ namespace cv { namespace gpu { namespace bf_knnmatch
     template <typename T> void match2Hamming_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
         const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
         int cc, cudaStream_t stream);
-}}}
+}
 
-namespace cv { namespace gpu { namespace bf_radius_match 
+namespace bf_radius_match 
 {
     template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
         const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
@@ -151,15 +153,17 @@ namespace cv { namespace gpu { namespace bf_radius_match
     template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
         const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
         int cc, cudaStream_t stream);
-}}}
-
-cv::gpu::BruteForceMatcher_GPU_base::BruteForceMatcher_GPU_base(DistType distType_) : distType(distType_)
-{
 }
 
+END_OPENCV_DEVICE_NAMESPACE
+
 ////////////////////////////////////////////////////////////////////
 // Train collection
 
+cv::gpu::BruteForceMatcher_GPU_base::BruteForceMatcher_GPU_base(DistType distType_) : distType(distType_)
+{
+}
+
 void cv::gpu::BruteForceMatcher_GPU_base::add(const vector<GpuMat>& descCollection)
 {
     trainDescCollection.insert(trainDescCollection.end(), descCollection.begin(), descCollection.end());
@@ -195,7 +199,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchSingle(const GpuMat& query, const
     if (query.empty() || train.empty())
         return;
 
-    using namespace cv::gpu::bf_match;
+    using namespace OPENCV_DEVICE_NAMESPACE_ bf_match;
 
     typedef void (*caller_t)(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
                              const DevMem2Di& trainIdx, const DevMem2Df& distance,
@@ -242,8 +246,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx,
     if (trainIdx.empty() || distance.empty())
         return;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat distanceCPU = distance;
+    Mat trainIdxCPU(trainIdx);
+    Mat distanceCPU(distance);
 
     matchConvert(trainIdxCPU, distanceCPU, matches);
 }
@@ -337,7 +341,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchCollection(const GpuMat& query, c
     if (query.empty() || trainCollection.empty())
         return;
 
-    using namespace cv::gpu::bf_match;
+    using namespace OPENCV_DEVICE_NAMESPACE_ bf_match;
 
     typedef void (*caller_t)(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
                              const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
@@ -384,9 +388,9 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx,
     if (trainIdx.empty() || imgIdx.empty() || distance.empty())
         return;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat imgIdxCPU = imgIdx;
-    Mat distanceCPU = distance;
+    Mat trainIdxCPU(trainIdx);
+    Mat imgIdxCPU(imgIdx);
+    Mat distanceCPU(distance);
 
     matchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, matches);
 }
@@ -448,7 +452,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatchSingle(const GpuMat& query, co
     if (query.empty() || train.empty())
         return;
 
-    using namespace cv::gpu::bf_knnmatch;
+    using namespace OPENCV_DEVICE_NAMESPACE_ bf_knnmatch;
 
     typedef void (*caller_t)(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask, 
                              const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
@@ -511,8 +515,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatchDownload(const GpuMat& trainId
     if (trainIdx.empty() || distance.empty())
         return;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat distanceCPU = distance;
+    Mat trainIdxCPU(trainIdx);
+    Mat distanceCPU(distance);
 
     knnMatchConvert(trainIdxCPU, distanceCPU, matches, compactResult);
 }
@@ -577,7 +581,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatch2Collection(const GpuMat& quer
     if (query.empty() || trainCollection.empty())
         return;
 
-    using namespace cv::gpu::bf_knnmatch;
+    using namespace OPENCV_DEVICE_NAMESPACE_ bf_knnmatch;
 
     typedef void (*caller_t)(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
                              const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
@@ -630,9 +634,9 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatch2Download(const GpuMat& trainI
     if (trainIdx.empty() || imgIdx.empty() || distance.empty())
         return;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat imgIdxCPU = imgIdx;
-    Mat distanceCPU = distance;
+    Mat trainIdxCPU(trainIdx);
+    Mat imgIdxCPU(imgIdx);
+    Mat distanceCPU(distance);
 
     knnMatch2Convert(trainIdxCPU, imgIdxCPU, distanceCPU, matches, compactResult);
 }
@@ -758,7 +762,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchSingle(const GpuMat& query,
     if (query.empty() || train.empty())
         return;
 
-    using namespace cv::gpu::bf_radius_match;
+    using namespace OPENCV_DEVICE_NAMESPACE_ bf_radius_match;
 
     typedef void (*caller_t)(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
                              const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
@@ -819,9 +823,9 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trai
     if (trainIdx.empty() || distance.empty() || nMatches.empty())
         return;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat distanceCPU = distance;
-    Mat nMatchesCPU = nMatches;
+    Mat trainIdxCPU(trainIdx);
+    Mat distanceCPU(distance);
+    Mat nMatchesCPU(nMatches);
 
     radiusMatchConvert(trainIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
 }
@@ -889,7 +893,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchCollection(const GpuMat& qu
     if (query.empty() || empty())
         return;
 
-    using namespace cv::gpu::bf_radius_match;
+    using namespace OPENCV_DEVICE_NAMESPACE_ bf_radius_match;
 
     typedef void (*caller_t)(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
                              const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
@@ -953,10 +957,10 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trai
     if (trainIdx.empty() || imgIdx.empty() || distance.empty() || nMatches.empty())
         return;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat imgIdxCPU = imgIdx;
-    Mat distanceCPU = distance;
-    Mat nMatchesCPU = nMatches;
+    Mat trainIdxCPU(trainIdx);
+    Mat imgIdxCPU(imgIdx);
+    Mat distanceCPU(distance);
+    Mat nMatchesCPU(nMatches);
 
     radiusMatchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
 }
diff --git a/modules/gpu/src/calib3d.cpp b/modules/gpu/src/calib3d.cpp
index 301ea8167ec3d621e4cf469d7fe3d7515f7dd8cd..8e6e8389d9595effbba411d882f0debcf302d54d 100644
--- a/modules/gpu/src/calib3d.cpp
+++ b/modules/gpu/src/calib3d.cpp
@@ -42,6 +42,10 @@
 
 #include "precomp.hpp"
 
+using namespace cv;
+using namespace cv::gpu;
+using namespace std;
+
 #if !defined(HAVE_CUDA)
 
 void cv::gpu::transformPoints(const GpuMat&, const Mat&, const Mat&, GpuMat&, Stream&) { throw_nogpu(); }
@@ -52,13 +56,31 @@ void cv::gpu::solvePnPRansac(const Mat&, const Mat&, const Mat&, const Mat&, Mat
 
 #else
 
-using namespace cv;
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace transform_points 
+namespace transform_points 
 {
     void call(const DevMem2D_<float3> src, const float* rot, const float* transl, DevMem2D_<float3> dst, cudaStream_t stream);
-}}}
+}
+
+namespace project_points 
+{
+    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, const float* proj, DevMem2D_<float2> dst, cudaStream_t stream);
+}
+
+namespace solve_pnp_ransac
+{
+    int maxNumIters();
+
+    void computeHypothesisScores(
+            const int num_hypotheses, const int num_points, const float* rot_matrices,
+            const float3* transl_vectors, const float3* object, const float2* image,
+            const float dist_threshold, int* hypothesis_scores);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
+
+using namespace OPENCV_DEVICE_NAMESPACE;
 
 namespace
 {
@@ -79,15 +101,9 @@ namespace
 
 void cv::gpu::transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec, GpuMat& dst, Stream& stream)
 {
-    ::transformPointsCaller(src, rvec, tvec, dst, StreamAccessor::getStream(stream));
+    transformPointsCaller(src, rvec, tvec, dst, StreamAccessor::getStream(stream));
 }
 
-namespace cv { namespace gpu { namespace project_points 
-{
-    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, const float* proj, DevMem2D_<float2> dst, cudaStream_t stream);
-}}}
-
-
 namespace
 {
     void projectPointsCaller(const GpuMat& src, const Mat& rvec, const Mat& tvec, const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, cudaStream_t stream)
@@ -109,20 +125,9 @@ namespace
 
 void cv::gpu::projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec, const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, Stream& stream)
 {
-    ::projectPointsCaller(src, rvec, tvec, camera_mat, dist_coef, dst, StreamAccessor::getStream(stream));
+    projectPointsCaller(src, rvec, tvec, camera_mat, dist_coef, dst, StreamAccessor::getStream(stream));
 }
 
-
-namespace cv { namespace gpu { namespace solve_pnp_ransac
-{
-    int maxNumIters();
-
-    void computeHypothesisScores(
-            const int num_hypotheses, const int num_points, const float* rot_matrices,
-            const float3* transl_vectors, const float3* object, const float2* image,
-            const float dist_threshold, int* hypothesis_scores);
-}}}
-
 namespace
 {
     // Selects subset_size random different points from [0, num_points - 1] range
diff --git a/modules/gpu/src/cascadeclassifier.cpp b/modules/gpu/src/cascadeclassifier.cpp
index 0af5fa252fb64d854fb9fa8bc4d50d6e5a215e6a..a6b7da9f7995589b102b26f2b9cf37858a60a7ea 100644
--- a/modules/gpu/src/cascadeclassifier.cpp
+++ b/modules/gpu/src/cascadeclassifier.cpp
@@ -46,7 +46,6 @@ using namespace cv;
 using namespace cv::gpu;
 using namespace std;
 
-
 #if !defined (HAVE_CUDA)
 
 cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU()  { throw_nogpu(); }
diff --git a/modules/gpu/src/color.cpp b/modules/gpu/src/color.cpp
index 69b00300a032e7414459a9bd9eccb01ef80f83ea..c4f8b609ce19c524e6dfcacd324823d506a51436 100644
--- a/modules/gpu/src/color.cpp
+++ b/modules/gpu/src/color.cpp
@@ -51,155 +51,158 @@ void cv::gpu::cvtColor(const GpuMat&, GpuMat&, int, int, Stream&) { throw_nogpu(
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu {  namespace device  
-{
-    #define OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name) \
-        void name(const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
-
-    #define OPENCV_GPU_DECLARE_CVTCOLOR_ALL(name) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _16u) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f)
-
-    #define OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(name) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_8u) \
-        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_32f)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgba)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr555)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr565)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr555)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr565)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr555)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr565)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr555)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr565)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgra)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgra)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr555)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr565)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_gray)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_gray)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_gray)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_gray)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_gray)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_gray)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv4)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgra)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb4)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgra)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz4)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgra)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hsv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hsv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hsv4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hsv4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hsv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hsv)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hsv4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hsv4)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_bgra)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hls)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hls)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hls4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hls4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hls)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hls)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hls4)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hls4)
-
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_rgb)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_rgba)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_bgra)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_bgr)
-    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_bgra)
-
-    #undef OPENCV_GPU_DECLARE_CVTCOLOR_ONE
-    #undef OPENCV_GPU_DECLARE_CVTCOLOR_ALL
-    #undef OPENCV_GPU_DECLARE_CVTCOLOR_8U32F
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+#define OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name) \
+    void name(const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
+
+#define OPENCV_GPU_DECLARE_CVTCOLOR_ALL(name) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _16u) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f)
+
+#define OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(name) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_8u) \
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_32f)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgba)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr555)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr565)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr555)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr565)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr555)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr565)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr555)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr565)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgra)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgra)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr555)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr565)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_gray)
+OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_gray)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_gray)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_gray)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_gray)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_gray)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv4)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgra)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb4)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgra)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz4)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz4)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgra)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hsv)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hsv)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hsv4)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hsv4)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hsv)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hsv)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hsv4)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hsv4)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_bgra)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hls)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hls)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hls4)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hls4)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hls)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hls)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hls4)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hls4)
+
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_rgb)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_rgba)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_bgra)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_bgr)
+OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_bgra)
+
+#undef OPENCV_GPU_DECLARE_CVTCOLOR_ONE
+#undef OPENCV_GPU_DECLARE_CVTCOLOR_ALL
+#undef OPENCV_GPU_DECLARE_CVTCOLOR_8U32F
+
+END_OPENCV_DEVICE_NAMESPACE
+
+using namespace OPENCV_DEVICE_NAMESPACE;
 
 namespace
 {
diff --git a/modules/gpu/src/cuda/bf_knnmatch.cu b/modules/gpu/src/cuda/bf_knnmatch.cu
index f53af9e6fae47a2ed55819767bbca92506a57421..c8b1171e22f7bdc9b45f9035baca2a991ad8ec3b 100644
--- a/modules/gpu/src/cuda/bf_knnmatch.cu
+++ b/modules/gpu/src/cuda/bf_knnmatch.cu
@@ -45,1115 +45,1117 @@
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace bf_knnmatch
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // Reduction
+namespace bf_knnmatch {
 
-    template <int BLOCK_SIZE> 
-    __device__ void findBestMatch(float& bestDistance1, float& bestDistance2, 
-                                  int& bestTrainIdx1, int& bestTrainIdx2, 
-                                  float* s_distance, int* s_trainIdx)
-    {
-        float myBestDistance1 = numeric_limits<float>::max(); 
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
+///////////////////////////////////////////////////////////////////////////////
+// Reduction
+
+template <int BLOCK_SIZE> 
+__device__ void findBestMatch(float& bestDistance1, float& bestDistance2, 
+                              int& bestTrainIdx1, int& bestTrainIdx2, 
+                              float* s_distance, int* s_trainIdx)
+{
+    float myBestDistance1 = numeric_limits<float>::max(); 
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
 
-        s_distance += threadIdx.y * BLOCK_SIZE;
-        s_trainIdx += threadIdx.y * BLOCK_SIZE;
+    s_distance += threadIdx.y * BLOCK_SIZE;
+    s_trainIdx += threadIdx.y * BLOCK_SIZE;
 
-        s_distance[threadIdx.x] = bestDistance1;
-        s_trainIdx[threadIdx.x] = bestTrainIdx1;
+    s_distance[threadIdx.x] = bestDistance1;
+    s_trainIdx[threadIdx.x] = bestTrainIdx1;
 
-        __syncthreads();
+    __syncthreads();
 
-        if (threadIdx.x == 0)
+    if (threadIdx.x == 0)
+    {
+        #pragma unroll
+        for (int i = 0; i < BLOCK_SIZE; ++i)
         {
-            #pragma unroll
-            for (int i = 0; i < BLOCK_SIZE; ++i)
+            float val = s_distance[i];
+
+            if (val < myBestDistance1)
+            {
+                myBestDistance2 = myBestDistance1;
+                myBestTrainIdx2 = myBestTrainIdx1;
+
+                myBestDistance1 = val;
+                myBestTrainIdx1 = s_trainIdx[i];
+            }
+            else if (val < myBestDistance2)
             {
-                float val = s_distance[i];
-
-                if (val < myBestDistance1)
-                {
-                    myBestDistance2 = myBestDistance1;
-                    myBestTrainIdx2 = myBestTrainIdx1;
-
-                    myBestDistance1 = val;
-                    myBestTrainIdx1 = s_trainIdx[i];
-                }
-                else if (val < myBestDistance2)
-                {
-                    myBestDistance2 = val;
-                    myBestTrainIdx2 = s_trainIdx[i];
-                }
+                myBestDistance2 = val;
+                myBestTrainIdx2 = s_trainIdx[i];
             }
         }
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        s_distance[threadIdx.x] = bestDistance2;
-        s_trainIdx[threadIdx.x] = bestTrainIdx2;
+    s_distance[threadIdx.x] = bestDistance2;
+    s_trainIdx[threadIdx.x] = bestTrainIdx2;
 
-        __syncthreads();
+    __syncthreads();
 
-        if (threadIdx.x == 0)
+    if (threadIdx.x == 0)
+    {
+        #pragma unroll
+        for (int i = 0; i < BLOCK_SIZE; ++i)
         {
-            #pragma unroll
-            for (int i = 0; i < BLOCK_SIZE; ++i)
-            {
-                float val = s_distance[i];
+            float val = s_distance[i];
 
-                if (val < myBestDistance2)
-                {
-                    myBestDistance2 = val;
-                    myBestTrainIdx2 = s_trainIdx[i];
-                }
+            if (val < myBestDistance2)
+            {
+                myBestDistance2 = val;
+                myBestTrainIdx2 = s_trainIdx[i];
             }
         }
+    }
 
-        bestDistance1 = myBestDistance1;
-        bestDistance2 = myBestDistance2;
+    bestDistance1 = myBestDistance1;
+    bestDistance2 = myBestDistance2;
 
-        bestTrainIdx1 = myBestTrainIdx1;
-        bestTrainIdx2 = myBestTrainIdx2;
-    }
+    bestTrainIdx1 = myBestTrainIdx1;
+    bestTrainIdx2 = myBestTrainIdx2;
+}
 
-    template <int BLOCK_SIZE> 
-    __device__ void findBestMatch(float& bestDistance1, float& bestDistance2, 
-                                   int& bestTrainIdx1, int& bestTrainIdx2, 
-                                   int& bestImgIdx1, int& bestImgIdx2, 
-                                   float* s_distance, int* s_trainIdx, int* s_imgIdx)
-    {
-        float myBestDistance1 = numeric_limits<float>::max(); 
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
-        int myBestImgIdx1 = -1;
-        int myBestImgIdx2 = -1;
+template <int BLOCK_SIZE> 
+__device__ void findBestMatch(float& bestDistance1, float& bestDistance2, 
+                               int& bestTrainIdx1, int& bestTrainIdx2, 
+                               int& bestImgIdx1, int& bestImgIdx2, 
+                               float* s_distance, int* s_trainIdx, int* s_imgIdx)
+{
+    float myBestDistance1 = numeric_limits<float>::max(); 
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
+    int myBestImgIdx1 = -1;
+    int myBestImgIdx2 = -1;
 
-        s_distance += threadIdx.y * BLOCK_SIZE;
-        s_trainIdx += threadIdx.y * BLOCK_SIZE;
-        s_imgIdx   += threadIdx.y * BLOCK_SIZE;
+    s_distance += threadIdx.y * BLOCK_SIZE;
+    s_trainIdx += threadIdx.y * BLOCK_SIZE;
+    s_imgIdx   += threadIdx.y * BLOCK_SIZE;
 
-        s_distance[threadIdx.x] = bestDistance1;
-        s_trainIdx[threadIdx.x] = bestTrainIdx1;
-        s_imgIdx[threadIdx.x]   = bestImgIdx1;
+    s_distance[threadIdx.x] = bestDistance1;
+    s_trainIdx[threadIdx.x] = bestTrainIdx1;
+    s_imgIdx[threadIdx.x]   = bestImgIdx1;
 
-        __syncthreads();
+    __syncthreads();
 
-        if (threadIdx.x == 0)
+    if (threadIdx.x == 0)
+    {
+        #pragma unroll
+        for (int i = 0; i < BLOCK_SIZE; ++i)
         {
-            #pragma unroll
-            for (int i = 0; i < BLOCK_SIZE; ++i)
+            float val = s_distance[i];
+
+            if (val < myBestDistance1)
+            {
+                myBestDistance2 = myBestDistance1;
+                myBestTrainIdx2 = myBestTrainIdx1;
+                myBestImgIdx2   = myBestImgIdx1;
+
+                myBestDistance1 = val;
+                myBestTrainIdx1 = s_trainIdx[i];
+                myBestImgIdx1   = s_imgIdx[i];
+            }
+            else if (val < myBestDistance2)
             {
-                float val = s_distance[i];
-
-                if (val < myBestDistance1)
-                {
-                    myBestDistance2 = myBestDistance1;
-                    myBestTrainIdx2 = myBestTrainIdx1;
-                    myBestImgIdx2   = myBestImgIdx1;
-
-                    myBestDistance1 = val;
-                    myBestTrainIdx1 = s_trainIdx[i];
-                    myBestImgIdx1   = s_imgIdx[i];
-                }
-                else if (val < myBestDistance2)
-                {
-                    myBestDistance2 = val;
-                    myBestTrainIdx2 = s_trainIdx[i];
-                    myBestImgIdx2   = s_imgIdx[i];
-                }
+                myBestDistance2 = val;
+                myBestTrainIdx2 = s_trainIdx[i];
+                myBestImgIdx2   = s_imgIdx[i];
             }
         }
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        s_distance[threadIdx.x] = bestDistance2;
-        s_trainIdx[threadIdx.x] = bestTrainIdx2;
-        s_imgIdx[threadIdx.x]   = bestImgIdx2;
+    s_distance[threadIdx.x] = bestDistance2;
+    s_trainIdx[threadIdx.x] = bestTrainIdx2;
+    s_imgIdx[threadIdx.x]   = bestImgIdx2;
 
-        __syncthreads();
+    __syncthreads();
 
-        if (threadIdx.x == 0)
+    if (threadIdx.x == 0)
+    {
+        #pragma unroll
+        for (int i = 0; i < BLOCK_SIZE; ++i)
         {
-            #pragma unroll
-            for (int i = 0; i < BLOCK_SIZE; ++i)
+            float val = s_distance[i];
+
+            if (val < myBestDistance2)
             {
-                float val = s_distance[i];
-
-                if (val < myBestDistance2)
-                {
-                    myBestDistance2 = val;
-                    myBestTrainIdx2 = s_trainIdx[i];
-                    myBestImgIdx2   = s_imgIdx[i];
-                }
+                myBestDistance2 = val;
+                myBestTrainIdx2 = s_trainIdx[i];
+                myBestImgIdx2   = s_imgIdx[i];
             }
         }
+    }
 
-        bestDistance1 = myBestDistance1;
-        bestDistance2 = myBestDistance2;
+    bestDistance1 = myBestDistance1;
+    bestDistance2 = myBestDistance2;
 
-        bestTrainIdx1 = myBestTrainIdx1;
-        bestTrainIdx2 = myBestTrainIdx2;
+    bestTrainIdx1 = myBestTrainIdx1;
+    bestTrainIdx2 = myBestTrainIdx2;
 
-        bestImgIdx1 = myBestImgIdx1;
-        bestImgIdx2 = myBestImgIdx2;
-    }
+    bestImgIdx1 = myBestImgIdx1;
+    bestImgIdx2 = myBestImgIdx2;
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match Unrolled Cached
+///////////////////////////////////////////////////////////////////////////////
+// Match Unrolled Cached
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename T, typename U> 
-    __device__ void loadQueryToSmem(int queryIdx, const DevMem2D_<T>& query, U* s_query)
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename T, typename U> 
+__device__ void loadQueryToSmem(int queryIdx, const DevMem2D_<T>& query, U* s_query)
+{
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
     {
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
+        s_query[threadIdx.y * MAX_DESC_LEN + loadX] = loadX < query.cols ? query.ptr(::min(queryIdx, query.rows - 1))[loadX] : 0;
+    }
+}
+
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__device__ void loopUnrolledCached(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
+                                   typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
+                                   float& bestDistance1, float& bestDistance2, 
+                                   int& bestTrainIdx1, int& bestTrainIdx2, 
+                                   int& bestImgIdx1, int& bestImgIdx2)
+{
+    for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
+    {
+        Dist dist;
+
         #pragma unroll
         for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
         {
             const int loadX = threadIdx.x + i * BLOCK_SIZE;
-            s_query[threadIdx.y * MAX_DESC_LEN + loadX] = loadX < query.cols ? query.ptr(min(queryIdx, query.rows - 1))[loadX] : 0;
-        }
-    }
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __device__ void loopUnrolledCached(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
-                                       typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
-                                       float& bestDistance1, float& bestDistance2, 
-                                       int& bestTrainIdx1, int& bestTrainIdx2, 
-                                       int& bestImgIdx1, int& bestImgIdx2)
-    {
-        for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
-        {
-            Dist dist;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-            #pragma unroll
-            for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+            if (loadX < train.cols)
             {
-                const int loadX = threadIdx.x + i * BLOCK_SIZE;
+                T val;
 
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
-
-                if (loadX < train.cols)
-                {
-                    T val;
+                ForceGlob<T>::Load(train.ptr(::min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+            }
 
-                    ForceGlob<T>::Load(train.ptr(min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                    s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-                }
+            __syncthreads();
 
-                __syncthreads();
+            #pragma unroll
+            for (int j = 0; j < BLOCK_SIZE; ++j)
+                dist.reduceIter(s_query[threadIdx.y * MAX_DESC_LEN + i * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-                #pragma unroll
-                for (int j = 0; j < BLOCK_SIZE; ++j)
-                    dist.reduceIter(s_query[threadIdx.y * MAX_DESC_LEN + i * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+            __syncthreads();
+        }
 
-                __syncthreads();
-            }
+        typename Dist::result_type distVal = dist;
 
-            typename Dist::result_type distVal = dist;
+        const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
 
-            const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
+        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx))
+        {
+            if (distVal < bestDistance1)
+            {
+                bestImgIdx2   = bestImgIdx1;
+                bestDistance2 = bestDistance1;
+                bestTrainIdx2 = bestTrainIdx1;
 
-            if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx))
+                bestImgIdx1   = imgIdx;
+                bestDistance1 = distVal;
+                bestTrainIdx1 = trainIdx;
+            }
+            else if (distVal < bestDistance2)
             {
-                if (distVal < bestDistance1)
-                {
-                    bestImgIdx2   = bestImgIdx1;
-                    bestDistance2 = bestDistance1;
-                    bestTrainIdx2 = bestTrainIdx1;
-
-                    bestImgIdx1   = imgIdx;
-                    bestDistance1 = distVal;
-                    bestTrainIdx1 = trainIdx;
-                }
-                else if (distVal < bestDistance2)
-                {
-                    bestImgIdx2   = imgIdx;
-                    bestDistance2 = distVal;
-                    bestTrainIdx2 = trainIdx;
-                }
+                bestImgIdx2   = imgIdx;
+                bestDistance2 = distVal;
+                bestTrainIdx2 = trainIdx;
             }
         }
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int2* bestTrainIdx, float2* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int2* bestTrainIdx, float2* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
 
-        loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
+    loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
 
-        float myBestDistance1 = numeric_limits<float>::max();
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
+    float myBestDistance1 = numeric_limits<float>::max();
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
 
-        loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestTrainIdx1, myBestTrainIdx2);
+    loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestTrainIdx1, myBestTrainIdx2);
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, s_distance, s_trainIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, s_distance, s_trainIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
-            bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
+        bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                             const DevMem2D_<int2>& trainIdx, const DevMem2D_<float2>& distance, 
-                             cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                         const DevMem2D_<int2>& trainIdx, const DevMem2D_<float2>& distance, 
+                         cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= BLOCK_SIZE ? MAX_DESC_LEN : BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= BLOCK_SIZE ? MAX_DESC_LEN : BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, int2* bestTrainIdx, int2* bestImgIdx, float2* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, int2* bestTrainIdx, int2* bestImgIdx, float2* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
 
-        loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
+    loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
 
-        float myBestDistance1 = numeric_limits<float>::max();
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
-        int myBestImgIdx1 = -1;
-        int myBestImgIdx2 = -1;
+    float myBestDistance1 = numeric_limits<float>::max();
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
+    int myBestImgIdx1 = -1;
+    int myBestImgIdx2 = -1;
 
-        Mask m = mask;
+    Mask m = mask;
 
-        for (int imgIdx = 0; imgIdx < n; ++imgIdx)
-        {
-            const DevMem2D_<T> train = trains[imgIdx];
-            m.next();
-            loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2);
-        }
+    for (int imgIdx = 0; imgIdx < n; ++imgIdx)
+    {
+        const DevMem2D_<T> train = trains[imgIdx];
+        m.next();
+        loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2);
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2, s_distance, s_trainIdx, s_imgIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2, s_distance, s_trainIdx, s_imgIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
-            bestImgIdx[queryIdx] = make_int2(myBestImgIdx1, myBestImgIdx2);
-            bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
+        bestImgIdx[queryIdx] = make_int2(myBestImgIdx1, myBestImgIdx2);
+        bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-                             const DevMem2D_<int2>& trainIdx, const DevMem2D_<int2>& imgIdx, const DevMem2D_<float2>& distance, 
-                             cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+                         const DevMem2D_<int2>& trainIdx, const DevMem2D_<int2>& imgIdx, const DevMem2D_<float2>& distance, 
+                         cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= 2 * BLOCK_SIZE ? MAX_DESC_LEN : 2 * BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= 2 * BLOCK_SIZE ? MAX_DESC_LEN : 2 * BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match Unrolled
+///////////////////////////////////////////////////////////////////////////////
+// Match Unrolled
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __device__ void loopUnrolled(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
-                                 typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
-                                 float& bestDistance1, float& bestDistance2, 
-                                 int& bestTrainIdx1, int& bestTrainIdx2, 
-                                 int& bestImgIdx1, int& bestImgIdx2)
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__device__ void loopUnrolled(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
+                             typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
+                             float& bestDistance1, float& bestDistance2, 
+                             int& bestTrainIdx1, int& bestTrainIdx2, 
+                             int& bestImgIdx1, int& bestImgIdx2)
+{
+    for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
     {
-        for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
+        Dist dist;
+
+        #pragma unroll
+        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
         {
-            Dist dist;
+            const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-            #pragma unroll
-            for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
-            {
-                const int loadX = threadIdx.x + i * BLOCK_SIZE;
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+            if (loadX < query.cols)
+            {
+                T val;
 
-                if (loadX < query.cols)
-                {
-                    T val;
+                ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-                    ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                    s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
+                ForceGlob<T>::Load(train.ptr(::min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+            }
 
-                    ForceGlob<T>::Load(train.ptr(min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                    s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-                }
+            __syncthreads();
 
-                __syncthreads();
+            #pragma unroll
+            for (int j = 0; j < BLOCK_SIZE; ++j)
+                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-                #pragma unroll
-                for (int j = 0; j < BLOCK_SIZE; ++j)
-                    dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+            __syncthreads();
+        }
 
-                __syncthreads();
-            }
+        typename Dist::result_type distVal = dist;
 
-            typename Dist::result_type distVal = dist;
+        const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
 
-            const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
+        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx))
+        {
+            if (distVal < bestDistance1)
+            {
+                bestImgIdx2   = bestImgIdx1;
+                bestDistance2 = bestDistance1;
+                bestTrainIdx2 = bestTrainIdx1;
 
-            if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx))
+                bestImgIdx1   = imgIdx;
+                bestDistance1 = distVal;
+                bestTrainIdx1 = trainIdx;
+            }
+            else if (distVal < bestDistance2)
             {
-                if (distVal < bestDistance1)
-                {
-                    bestImgIdx2   = bestImgIdx1;
-                    bestDistance2 = bestDistance1;
-                    bestTrainIdx2 = bestTrainIdx1;
-
-                    bestImgIdx1   = imgIdx;
-                    bestDistance1 = distVal;
-                    bestTrainIdx1 = trainIdx;
-                }
-                else if (distVal < bestDistance2)
-                {
-                    bestImgIdx2   = imgIdx;
-                    bestDistance2 = distVal;
-                    bestTrainIdx2 = trainIdx;
-                }
+                bestImgIdx2   = imgIdx;
+                bestDistance2 = distVal;
+                bestTrainIdx2 = trainIdx;
             }
         }
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int2* bestTrainIdx, float2* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int2* bestTrainIdx, float2* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        float myBestDistance1 = numeric_limits<float>::max();
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
+    float myBestDistance1 = numeric_limits<float>::max();
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
 
-        loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestTrainIdx1, myBestTrainIdx2);
+    loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestTrainIdx1, myBestTrainIdx2);
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, s_distance, s_trainIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, s_distance, s_trainIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
-            bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
+        bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                       const DevMem2D_<int2>& trainIdx, const DevMem2D_<float2>& distance, 
-                       cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                   const DevMem2D_<int2>& trainIdx, const DevMem2D_<float2>& distance, 
+                   cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, int2* bestTrainIdx, int2* bestImgIdx, float2* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, int2* bestTrainIdx, int2* bestImgIdx, float2* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        float myBestDistance1 = numeric_limits<float>::max();
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
-        int myBestImgIdx1 = -1;
-        int myBestImgIdx2 = -1;
+    float myBestDistance1 = numeric_limits<float>::max();
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
+    int myBestImgIdx1 = -1;
+    int myBestImgIdx2 = -1;
 
-        Mask m = mask;
+    Mask m = mask;
 
-        for (int imgIdx = 0; imgIdx < n; ++imgIdx)
-        {
-            const DevMem2D_<T> train = trains[imgIdx];
-            m.next();
-            loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2);
-        }
+    for (int imgIdx = 0; imgIdx < n; ++imgIdx)
+    {
+        const DevMem2D_<T> train = trains[imgIdx];
+        m.next();
+        loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2);
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2, s_distance, s_trainIdx, s_imgIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2, s_distance, s_trainIdx, s_imgIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
-            bestImgIdx[queryIdx] = make_int2(myBestImgIdx1, myBestImgIdx2);
-            bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
+        bestImgIdx[queryIdx] = make_int2(myBestImgIdx1, myBestImgIdx2);
+        bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-                       const DevMem2D_<int2>& trainIdx, const DevMem2D_<int2>& imgIdx, const DevMem2D_<float2>& distance, 
-                       cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+                   const DevMem2D_<int2>& trainIdx, const DevMem2D_<int2>& imgIdx, const DevMem2D_<float2>& distance, 
+                   cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match
+///////////////////////////////////////////////////////////////////////////////
+// Match
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    __device__ void loop(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
-                         typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
-                         float& bestDistance1, float& bestDistance2, 
-                         int& bestTrainIdx1, int& bestTrainIdx2, 
-                         int& bestImgIdx1, int& bestImgIdx2)
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+__device__ void loop(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
+                     typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
+                     float& bestDistance1, float& bestDistance2, 
+                     int& bestTrainIdx1, int& bestTrainIdx2, 
+                     int& bestImgIdx1, int& bestImgIdx2)
+{
+    for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
     {
-        for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
+        Dist dist;
+
+        for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
         {
-            Dist dist;
+            const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-            for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
-            {
-                const int loadX = threadIdx.x + i * BLOCK_SIZE;
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+            if (loadX < query.cols)
+            {
+                T val;
 
-                if (loadX < query.cols)
-                {
-                    T val;
+                ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-                    ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                    s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
+                ForceGlob<T>::Load(train.ptr(::min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+            }
 
-                    ForceGlob<T>::Load(train.ptr(min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                    s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-                }
+            __syncthreads();
 
-                __syncthreads();
+            #pragma unroll
+            for (int j = 0; j < BLOCK_SIZE; ++j)
+                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-                #pragma unroll
-                for (int j = 0; j < BLOCK_SIZE; ++j)
-                    dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+            __syncthreads();
+        }
 
-                __syncthreads();
-            }
+        typename Dist::result_type distVal = dist;
 
-            typename Dist::result_type distVal = dist;
+        const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
 
-            const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
+        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx))
+        {
+            if (distVal < bestDistance1)
+            {
+                bestImgIdx2   = bestImgIdx1;
+                bestDistance2 = bestDistance1;
+                bestTrainIdx2 = bestTrainIdx1;
 
-            if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx))
+                bestImgIdx1   = imgIdx;
+                bestDistance1 = distVal;
+                bestTrainIdx1 = trainIdx;
+            }
+            else if (distVal < bestDistance2)
             {
-                if (distVal < bestDistance1)
-                {
-                    bestImgIdx2   = bestImgIdx1;
-                    bestDistance2 = bestDistance1;
-                    bestTrainIdx2 = bestTrainIdx1;
-
-                    bestImgIdx1   = imgIdx;
-                    bestDistance1 = distVal;
-                    bestTrainIdx1 = trainIdx;
-                }
-                else if (distVal < bestDistance2)
-                {
-                    bestImgIdx2   = imgIdx;
-                    bestDistance2 = distVal;
-                    bestTrainIdx2 = trainIdx;
-                }
+                bestImgIdx2   = imgIdx;
+                bestDistance2 = distVal;
+                bestTrainIdx2 = trainIdx;
             }
         }
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    __global__ void match(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int2* bestTrainIdx, float2* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+__global__ void match(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int2* bestTrainIdx, float2* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        float myBestDistance1 = numeric_limits<float>::max();
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
+    float myBestDistance1 = numeric_limits<float>::max();
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
 
-        loop<BLOCK_SIZE, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestTrainIdx1, myBestTrainIdx2);
+    loop<BLOCK_SIZE, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestTrainIdx1, myBestTrainIdx2);
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, s_distance, s_trainIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, s_distance, s_trainIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
-            bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
+        bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-               const DevMem2D_<int2>& trainIdx, const DevMem2D_<float2>& distance, 
-               cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+           const DevMem2D_<int2>& trainIdx, const DevMem2D_<float2>& distance, 
+           cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    __global__ void match(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, int2* bestTrainIdx, int2* bestImgIdx, float2* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+__global__ void match(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, int2* bestTrainIdx, int2* bestImgIdx, float2* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        float myBestDistance1 = numeric_limits<float>::max();
-        float myBestDistance2 = numeric_limits<float>::max();
-        int myBestTrainIdx1 = -1;
-        int myBestTrainIdx2 = -1;
-        int myBestImgIdx1 = -1;
-        int myBestImgIdx2 = -1;
+    float myBestDistance1 = numeric_limits<float>::max();
+    float myBestDistance2 = numeric_limits<float>::max();
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
+    int myBestImgIdx1 = -1;
+    int myBestImgIdx2 = -1;
 
-        Mask m = mask;
+    Mask m = mask;
 
-        for (int imgIdx = 0; imgIdx < n; ++imgIdx)
-        {
-            const DevMem2D_<T> train = trains[imgIdx];
-            m.next();
-            loop<BLOCK_SIZE, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2);
-        }
+    for (int imgIdx = 0; imgIdx < n; ++imgIdx)
+    {
+        const DevMem2D_<T> train = trains[imgIdx];
+        m.next();
+        loop<BLOCK_SIZE, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2);
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2, s_distance, s_trainIdx, s_imgIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance1, myBestDistance2, myBestTrainIdx1, myBestTrainIdx2, myBestImgIdx1, myBestImgIdx2, s_distance, s_trainIdx, s_imgIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
-            bestImgIdx[queryIdx] = make_int2(myBestImgIdx1, myBestImgIdx2);
-            bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = make_int2(myBestTrainIdx1, myBestTrainIdx2);
+        bestImgIdx[queryIdx] = make_int2(myBestImgIdx1, myBestImgIdx2);
+        bestDistance[queryIdx] = make_float2(myBestDistance1, myBestDistance2);
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-               const DevMem2D_<int2>& trainIdx, const DevMem2D_<int2>& imgIdx, const DevMem2D_<float2>& distance, 
-               cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+           const DevMem2D_<int2>& trainIdx, const DevMem2D_<int2>& imgIdx, const DevMem2D_<float2>& distance, 
+           cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // knnMatch 2 dispatcher
+///////////////////////////////////////////////////////////////////////////////
+// knnMatch 2 dispatcher
 
-    template <typename Dist, typename T, typename Mask> 
-    void match2Dispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                          const DevMem2Db& trainIdx, const DevMem2Db& distance, 
-                          int cc, cudaStream_t stream)
+template <typename Dist, typename T, typename Mask> 
+void match2Dispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                      const DevMem2Db& trainIdx, const DevMem2Db& distance, 
+                      int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolledCached<16, 64, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolledCached<16, 128, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
+        matchUnrolledCached<16, 64, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
     }
-
-    template <typename Dist, typename T, typename Mask> 
-    void match2Dispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-                          const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
-                          int cc, cudaStream_t stream)
+    else if (query.cols <= 128)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolledCached<16, 64, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolledCached<16, 128, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
-        }
+        matchUnrolledCached<16, 128, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
     }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // Calc distance kernel
-
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
-    __global__ void calcDistanceUnrolled(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, PtrStepf allDist)
+    /*else if (query.cols <= 256)
     {
-        extern __shared__ int smem[];
+        matchUnrolled<16, 256, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }*/
+    else
+    {
+        match<16, Dist>(query, train, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+}
 
-        const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
-        const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+template <typename Dist, typename T, typename Mask> 
+void match2Dispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+                      const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
+                      int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
+    {
+        matchUnrolledCached<16, 64, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+    else if (query.cols <= 128)
+    {
+        matchUnrolledCached<16, 128, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+    /*else if (query.cols <= 256)
+    {
+        matchUnrolled<16, 256, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }*/
+    else
+    {
+        match<16, Dist>(query, trains, n, mask, static_cast< DevMem2D_<int2> >(trainIdx), static_cast< DevMem2D_<int2> >(imgIdx), static_cast< DevMem2D_<float2> > (distance), stream);
+    }
+}
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+///////////////////////////////////////////////////////////////////////////////
+// Calc distance kernel
 
-        Dist dist;
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
+__global__ void calcDistanceUnrolled(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, PtrStepf allDist)
+{
+    extern __shared__ int smem[];
 
-        #pragma unroll
-        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
-        {
-            const int loadX = threadIdx.x + i * BLOCK_SIZE;
+    const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
+    const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
 
-            if (loadX < query.cols)
-            {
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = query.ptr(min(queryIdx, query.rows - 1))[loadX];
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = train.ptr(min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1))[loadX];
-            }
-            else
-            {                
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
-            }
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-            __syncthreads();
+    Dist dist;
 
-            #pragma unroll
-            for (int j = 0; j < BLOCK_SIZE; ++j)
-                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+    {
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-            __syncthreads();
+        if (loadX < query.cols)
+        {
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = query.ptr(::min(queryIdx, query.rows - 1))[loadX];
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = train.ptr(::min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1))[loadX];
+        }
+        else
+        {                
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
         }
 
-        if (queryIdx < query.rows && trainIdx < train.rows)
-        {
-            float distVal = numeric_limits<float>::max();
+        __syncthreads();
 
-            if (mask(queryIdx, trainIdx))
-                distVal = (typename Dist::result_type)dist;
+        #pragma unroll
+        for (int j = 0; j < BLOCK_SIZE; ++j)
+            dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-            allDist.ptr(queryIdx)[trainIdx] = distVal;
-        }
+        __syncthreads();
     }
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void calcDistanceUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, const DevMem2Df& allDist, cudaStream_t stream)
+    if (queryIdx < query.rows && trainIdx < train.rows)
     {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
-
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+        float distVal = numeric_limits<float>::max();
 
-        calcDistanceUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, allDist);
-        cudaSafeCall( cudaGetLastError() );
+        if (mask(queryIdx, trainIdx))
+            distVal = (typename Dist::result_type)dist;
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        allDist.ptr(queryIdx)[trainIdx] = distVal;
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
-    __global__ void calcDistance(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, PtrStepf allDist)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void calcDistanceUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, const DevMem2Df& allDist, cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-        const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
-        const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    calcDistanceUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, allDist);
+    cudaSafeCall( cudaGetLastError() );
 
-        Dist dist;
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-        for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
-        {
-            const int loadX = threadIdx.x + i * BLOCK_SIZE;
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
+__global__ void calcDistance(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, PtrStepf allDist)
+{
+    extern __shared__ int smem[];
 
-            if (loadX < query.cols)
-            {
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = query.ptr(min(queryIdx, query.rows - 1))[loadX];
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = train.ptr(min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1))[loadX];
-            }
-            else
-            {                
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
-            }
+    const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
+    const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
 
-            __syncthreads();
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-            #pragma unroll
-            for (int j = 0; j < BLOCK_SIZE; ++j)
-                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+    Dist dist;
 
-            __syncthreads();
-        }
+    for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
+    {
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-        if (queryIdx < query.rows && trainIdx < train.rows)
+        if (loadX < query.cols)
         {
-            float distVal = numeric_limits<float>::max();
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = query.ptr(::min(queryIdx, query.rows - 1))[loadX];
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = train.ptr(::min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1))[loadX];
+        }
+        else
+        {                
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+        }
 
-            if (mask(queryIdx, trainIdx))
-                distVal = (typename Dist::result_type)dist;
+        __syncthreads();
 
-            allDist.ptr(queryIdx)[trainIdx] = distVal;
-        }
+        #pragma unroll
+        for (int j = 0; j < BLOCK_SIZE; ++j)
+            dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+
+        __syncthreads();
     }
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void calcDistance(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, const DevMem2Df& allDist, cudaStream_t stream)
+    if (queryIdx < query.rows && trainIdx < train.rows)
     {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
+        float distVal = numeric_limits<float>::max();
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
-
-        calcDistance<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, allDist);
-        cudaSafeCall( cudaGetLastError() );
+        if (mask(queryIdx, trainIdx))
+            distVal = (typename Dist::result_type)dist;
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        allDist.ptr(queryIdx)[trainIdx] = distVal;
     }
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Calc Distance dispatcher
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void calcDistance(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, const DevMem2Df& allDist, cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-    template <typename Dist, typename T, typename Mask> 
-    void calcDistanceDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                                const DevMem2Df& allDist, 
-                                int cc, cudaStream_t stream)
-    {
-        if (query.cols <= 64)
-        {
-            calcDistanceUnrolled<16, 64, Dist>(query, train, mask, allDist, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            calcDistanceUnrolled<16, 128, Dist>(query, train, mask, allDist, stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            calcDistanceUnrolled<16, 256, Dist>(query, train, mask, allDist, stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            calcDistanceUnrolled<16, 512, Dist>(query, train, mask, allDist, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            calcDistanceUnrolled<16, 1024, Dist>(query, train, mask, allDist, stream);
-        }*/
-        else
-        {
-            calcDistance<16, Dist>(query, train, mask, allDist, stream);
-        }
-    }
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // find knn match kernel
+    calcDistance<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, allDist);
+    cudaSafeCall( cudaGetLastError() );
 
-    template <int BLOCK_SIZE> 
-    __global__ void findBestMatch(DevMem2Df allDist, int i, PtrStepi trainIdx, PtrStepf distance)
-    {
-        const int SMEM_SIZE = BLOCK_SIZE > 64 ? BLOCK_SIZE : 64;
-        __shared__ float s_dist[SMEM_SIZE];
-        __shared__ int s_trainIdx[SMEM_SIZE];
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-        const int queryIdx = blockIdx.x;
+///////////////////////////////////////////////////////////////////////////////
+// Calc Distance dispatcher
 
-        float* allDistRow = allDist.ptr(queryIdx);
+template <typename Dist, typename T, typename Mask> 
+void calcDistanceDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                            const DevMem2Df& allDist, 
+                            int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
+    {
+        calcDistanceUnrolled<16, 64, Dist>(query, train, mask, allDist, stream);
+    }
+    else if (query.cols <= 128)
+    {
+        calcDistanceUnrolled<16, 128, Dist>(query, train, mask, allDist, stream);
+    }
+    /*else if (query.cols <= 256)
+    {
+        calcDistanceUnrolled<16, 256, Dist>(query, train, mask, allDist, stream);
+    }
+    else if (query.cols <= 512)
+    {            
+        calcDistanceUnrolled<16, 512, Dist>(query, train, mask, allDist, stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        calcDistanceUnrolled<16, 1024, Dist>(query, train, mask, allDist, stream);
+    }*/
+    else
+    {
+        calcDistance<16, Dist>(query, train, mask, allDist, stream);
+    }
+}
 
-        float dist = numeric_limits<float>::max();
-        int bestIdx = -1;
-        
-        for (int i = threadIdx.x; i < allDist.cols; i += BLOCK_SIZE)
-        {
-            float reg = allDistRow[i];
-            if (reg < dist)
-            {
-                dist = reg;
-                bestIdx = i;
-            }
-        }
+///////////////////////////////////////////////////////////////////////////////
+// find knn match kernel
 
-        s_dist[threadIdx.x] = dist;
-        s_trainIdx[threadIdx.x] = bestIdx;
-        __syncthreads();
+template <int BLOCK_SIZE> 
+__global__ void findBestMatch(DevMem2Df allDist, int i, PtrStepi trainIdx, PtrStepf distance)
+{
+    const int SMEM_SIZE = BLOCK_SIZE > 64 ? BLOCK_SIZE : 64;
+    __shared__ float s_dist[SMEM_SIZE];
+    __shared__ int s_trainIdx[SMEM_SIZE];
 
-        reducePredVal<BLOCK_SIZE>(s_dist, dist, s_trainIdx, bestIdx, threadIdx.x, less<volatile float>());
+    const int queryIdx = blockIdx.x;
 
-        if (threadIdx.x == 0)
-        {
-            if (dist < numeric_limits<float>::max())
-            {
-                allDistRow[bestIdx] = numeric_limits<float>::max();
-                trainIdx.ptr(queryIdx)[i] = bestIdx;
-                distance.ptr(queryIdx)[i] = dist;
-            }
-        }
-    }
+    float* allDistRow = allDist.ptr(queryIdx);
 
-    template <int BLOCK_SIZE> 
-    void findKnnMatch(int k, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2Df& allDist, cudaStream_t stream)
+    float dist = numeric_limits<float>::max();
+    int bestIdx = -1;
+    
+    for (int i = threadIdx.x; i < allDist.cols; i += BLOCK_SIZE)
     {
-        const dim3 block(BLOCK_SIZE, 1, 1);
-        const dim3 grid(trainIdx.rows, 1, 1);
-
-        for (int i = 0; i < k; ++i)
+        float reg = allDistRow[i];
+        if (reg < dist)
         {
-            findBestMatch<BLOCK_SIZE><<<grid, block, 0, stream>>>(allDist, i, trainIdx, distance);
-            cudaSafeCall( cudaGetLastError() );
+            dist = reg;
+            bestIdx = i;
         }
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
     }
 
-    void findKnnMatchDispatcher(int k, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream)
-    {
-        findKnnMatch<256>(k, static_cast<DevMem2Di>(trainIdx), static_cast<DevMem2Df>(distance), allDist, stream);
-    }
+    s_dist[threadIdx.x] = dist;
+    s_trainIdx[threadIdx.x] = bestIdx;
+    __syncthreads();
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // knn match Dispatcher
+    reducePredVal<BLOCK_SIZE>(s_dist, dist, s_trainIdx, bestIdx, threadIdx.x, less<volatile float>());
 
-    template <typename Dist, typename T, typename Mask>
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, int k, const Mask& mask, 
-        const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
-        int cc, cudaStream_t stream)
+    if (threadIdx.x == 0)
     {
-        if (k == 2)
-        {
-            match2Dispatcher<Dist>(query, train, mask, trainIdx, distance, cc, stream);
-        }
-        else
+        if (dist < numeric_limits<float>::max())
         {
-            calcDistanceDispatcher<Dist>(query, train, mask, allDist, cc, stream);
-            findKnnMatchDispatcher(k, trainIdx, distance, allDist, cc, stream);
+            allDistRow[bestIdx] = numeric_limits<float>::max();
+            trainIdx.ptr(queryIdx)[i] = bestIdx;
+            distance.ptr(queryIdx)[i] = dist;
         }
-    }     
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    // knn match caller
-
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask, 
-        const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
-        int cc, cudaStream_t stream)
-    {
-        if (mask.data)
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
-        else
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
     }
+}
 
-    template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template <int BLOCK_SIZE> 
+void findKnnMatch(int k, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2Df& allDist, cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, 1, 1);
+    const dim3 grid(trainIdx.rows, 1, 1);
 
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask, 
-        const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist,
-        int cc, cudaStream_t stream)
+    for (int i = 0; i < k; ++i)
     {
-        if (mask.data)
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
-        else
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+        findBestMatch<BLOCK_SIZE><<<grid, block, 0, stream>>>(allDist, i, trainIdx, distance);
+        cudaSafeCall( cudaGetLastError() );
     }
 
-    //template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask,
-        const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
-        int cc, cudaStream_t stream)
-    {
-        if (mask.data)
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
-        else
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
-    }
+void findKnnMatchDispatcher(int k, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream)
+{
+    findKnnMatch<256>(k, static_cast<DevMem2Di>(trainIdx), static_cast<DevMem2Df>(distance), allDist, stream);
+}
 
-    template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+///////////////////////////////////////////////////////////////////////////////
+// knn match Dispatcher
 
-    template <typename T> void match2L1_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
-        const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
-        int cc, cudaStream_t stream)
+template <typename Dist, typename T, typename Mask>
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, int k, const Mask& mask, 
+    const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
+    int cc, cudaStream_t stream)
+{
+    if (k == 2)
     {
-        if (masks.data)
-            match2Dispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
-        else
-            match2Dispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+        match2Dispatcher<Dist>(query, train, mask, trainIdx, distance, cc, stream);
     }
-    
-    template void match2L1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2L1_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2L1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2L1_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2L1_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2L1_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-
-    template <typename T> void match2L2_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
-        const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
-        int cc, cudaStream_t stream)
+    else
     {
-        if (masks.data)
-            match2Dispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
-        else
-            match2Dispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+        calcDistanceDispatcher<Dist>(query, train, mask, allDist, cc, stream);
+        findKnnMatchDispatcher(k, trainIdx, distance, allDist, cc, stream);
     }
-    
-    //template void match2L2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2L2_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2L2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2L2_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2L2_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Di& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2L2_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    
-    template <typename T> void match2Hamming_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
-        const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
-        int cc, cudaStream_t stream)
-    {
-        if (masks.data)
-            match2Dispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
-        else
-            match2Dispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
-    }
-    
-    template void match2Hamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2Hamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2Hamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    //template void match2Hamming_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-    template void match2Hamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
-}}}
+}     
+
+///////////////////////////////////////////////////////////////////////////////
+// knn match caller
+
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask, 
+    const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
+    else
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+}
+
+template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask, 
+    const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist,
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
+    else
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+}
+
+//template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, int k, const DevMem2Db& mask,
+    const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
+    else
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+}
+
+template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, int k, const DevMem2Db& mask, const DevMem2Db& trainIdx, const DevMem2Db& distance, const DevMem2Df& allDist, int cc, cudaStream_t stream);
+
+template <typename T> void match2L1_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
+    const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
+    int cc, cudaStream_t stream)
+{
+    if (masks.data)
+        match2Dispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
+    else
+        match2Dispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+}
+
+template void match2L1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2L1_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2L1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2L1_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2L1_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2L1_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+
+template <typename T> void match2L2_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
+    const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
+    int cc, cudaStream_t stream)
+{
+    if (masks.data)
+        match2Dispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
+    else
+        match2Dispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+}
+
+//template void match2L2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2L2_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2L2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2L2_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2L2_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Di& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2L2_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+
+template <typename T> void match2Hamming_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
+    const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, 
+    int cc, cudaStream_t stream)
+{
+    if (masks.data)
+        match2Dispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
+    else
+        match2Dispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+}
+
+template void match2Hamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2Hamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2Hamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+//template void match2Hamming_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+template void match2Hamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Db& trainIdx, const DevMem2Db& imgIdx, const DevMem2Db& distance, int cc, cudaStream_t stream);
+
+} // namespace bf_knnmatch
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/bf_match.cu b/modules/gpu/src/cuda/bf_match.cu
index e46939fa9f032900e639474d992f8865d5c132e8..0ab56be630a2d3b981163fb8f08ee50b6fd6517b 100644
--- a/modules/gpu/src/cuda/bf_match.cu
+++ b/modules/gpu/src/cuda/bf_match.cu
@@ -45,734 +45,736 @@
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace bf_match
+namespace bf_match {
+
+///////////////////////////////////////////////////////////////////////////////
+// Reduction
+
+template <int BLOCK_SIZE> 
+__device__ void findBestMatch(float& bestDistance, int& bestTrainIdx, float* s_distance, int* s_trainIdx)
 {
-    ///////////////////////////////////////////////////////////////////////////////
-    // Reduction
+    s_distance += threadIdx.y * BLOCK_SIZE;
+    s_trainIdx += threadIdx.y * BLOCK_SIZE;
 
-    template <int BLOCK_SIZE> 
-    __device__ void findBestMatch(float& bestDistance, int& bestTrainIdx, float* s_distance, int* s_trainIdx)
-    {
-        s_distance += threadIdx.y * BLOCK_SIZE;
-        s_trainIdx += threadIdx.y * BLOCK_SIZE;
+    s_distance[threadIdx.x] = bestDistance;
+    s_trainIdx[threadIdx.x] = bestTrainIdx;
 
-        s_distance[threadIdx.x] = bestDistance;
-        s_trainIdx[threadIdx.x] = bestTrainIdx;
+    __syncthreads();
 
-        __syncthreads();
+    reducePredVal<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, threadIdx.x, less<volatile float>());
+}
 
-        reducePredVal<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, threadIdx.x, less<volatile float>());
-    }
+template <int BLOCK_SIZE> 
+__device__ void findBestMatch(float& bestDistance, int& bestTrainIdx, int& bestImgIdx, float* s_distance, int* s_trainIdx, int* s_imgIdx)
+{
+    s_distance += threadIdx.y * BLOCK_SIZE;
+    s_trainIdx += threadIdx.y * BLOCK_SIZE;
+    s_imgIdx   += threadIdx.y * BLOCK_SIZE;
 
-    template <int BLOCK_SIZE> 
-    __device__ void findBestMatch(float& bestDistance, int& bestTrainIdx, int& bestImgIdx, float* s_distance, int* s_trainIdx, int* s_imgIdx)
-    {
-        s_distance += threadIdx.y * BLOCK_SIZE;
-        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;
 
-        s_distance[threadIdx.x] = bestDistance;
-        s_trainIdx[threadIdx.x] = bestTrainIdx;
-        s_imgIdx  [threadIdx.x] = bestImgIdx;
+    __syncthreads();
 
-        __syncthreads();
+    reducePredVal2<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, s_imgIdx, bestImgIdx, threadIdx.x, less<volatile float>());
+}
 
-        reducePredVal2<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, s_imgIdx, bestImgIdx, threadIdx.x, less<volatile float>());
-    }
+///////////////////////////////////////////////////////////////////////////////
+// Match Unrolled Cached
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match Unrolled Cached
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename T, typename U> 
+__device__ void loadQueryToSmem(int queryIdx, const DevMem2D_<T>& query, U* s_query)
+{
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+    {
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
+        s_query[threadIdx.y * MAX_DESC_LEN + loadX] = loadX < query.cols ? query.ptr(::min(queryIdx, query.rows - 1))[loadX] : 0;
+    }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename T, typename U> 
-    __device__ void loadQueryToSmem(int queryIdx, const DevMem2D_<T>& query, U* s_query)
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__device__ void loopUnrolledCached(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
+                                   typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
+                                   float& bestDistance, int& bestTrainIdx, int& bestImgIdx)
+{
+    for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
     {
+        Dist dist;
+
         #pragma unroll
         for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
         {
             const int loadX = threadIdx.x + i * BLOCK_SIZE;
-            s_query[threadIdx.y * MAX_DESC_LEN + loadX] = loadX < query.cols ? query.ptr(min(queryIdx, query.rows - 1))[loadX] : 0;
-        }
-    }
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __device__ void loopUnrolledCached(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
-                                       typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
-                                       float& bestDistance, int& bestTrainIdx, int& bestImgIdx)
-    {
-        for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
-        {
-            Dist dist;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-            #pragma unroll
-            for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+            if (loadX < train.cols)
             {
-                const int loadX = threadIdx.x + i * BLOCK_SIZE;
+                T val;
 
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
-
-                if (loadX < train.cols)
-                {
-                    T val;
-
-                    ForceGlob<T>::Load(train.ptr(min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                    s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-                }
+                ForceGlob<T>::Load(train.ptr(::min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+            }
 
-                __syncthreads();
+            __syncthreads();
 
-                #pragma unroll
-                for (int j = 0; j < BLOCK_SIZE; ++j)
-                    dist.reduceIter(s_query[threadIdx.y * MAX_DESC_LEN + i * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+            #pragma unroll
+            for (int j = 0; j < BLOCK_SIZE; ++j)
+                dist.reduceIter(s_query[threadIdx.y * MAX_DESC_LEN + i * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-                __syncthreads();
-            }
+            __syncthreads();
+        }
 
-            typename Dist::result_type distVal = dist;
+        typename Dist::result_type distVal = dist;
 
-            const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
+        const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
 
-            if (queryIdx < query.rows && trainIdx < train.rows && distVal < bestDistance && mask(queryIdx, trainIdx))
-            {
-                bestImgIdx = imgIdx;
-                bestDistance = distVal;
-                bestTrainIdx = trainIdx;
-            }
+        if (queryIdx < query.rows && trainIdx < train.rows && distVal < bestDistance && mask(queryIdx, trainIdx))
+        {
+            bestImgIdx = imgIdx;
+            bestDistance = distVal;
+            bestTrainIdx = trainIdx;
         }
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int* bestTrainIdx, float* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int* bestTrainIdx, float* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
 
-        loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
+    loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
 
-        float myBestDistance = numeric_limits<float>::max();
-        int myBestTrainIdx = -1;
+    float myBestDistance = numeric_limits<float>::max();
+    int myBestTrainIdx = -1;
 
-        loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance, myBestTrainIdx, myBestTrainIdx);
+    loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance, myBestTrainIdx, myBestTrainIdx);
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, s_distance, s_trainIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, s_distance, s_trainIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = myBestTrainIdx;
-            bestDistance[queryIdx] = myBestDistance;
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestDistance[queryIdx] = myBestDistance;
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                             const DevMem2Di& trainIdx, const DevMem2Df& distance, 
-                             cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                         const DevMem2Di& trainIdx, const DevMem2Df& distance, 
+                         cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= BLOCK_SIZE ? MAX_DESC_LEN : BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= BLOCK_SIZE ? MAX_DESC_LEN : BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, 
-                                        int* bestTrainIdx, int* bestImgIdx, float* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__global__ void matchUnrolledCached(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, 
+                                    int* bestTrainIdx, int* bestImgIdx, float* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * MAX_DESC_LEN);
 
-        loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
+    loadQueryToSmem<BLOCK_SIZE, MAX_DESC_LEN>(queryIdx, query, s_query);
 
-        float myBestDistance = numeric_limits<float>::max();
-        int myBestTrainIdx = -1;
-        int myBestImgIdx = -1;
+    float myBestDistance = numeric_limits<float>::max();
+    int myBestTrainIdx = -1;
+    int myBestImgIdx = -1;
 
-        Mask m = mask;
+    Mask m = mask;
 
-        for (int imgIdx = 0; imgIdx < n; ++imgIdx)
-        {
-            const DevMem2D_<T> train = trains[imgIdx];
-            m.next();
-            loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance, myBestTrainIdx, myBestImgIdx);
-        }
+    for (int imgIdx = 0; imgIdx < n; ++imgIdx)
+    {
+        const DevMem2D_<T> train = trains[imgIdx];
+        m.next();
+        loopUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance, myBestTrainIdx, myBestImgIdx);
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    int* s_imgIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, myBestImgIdx, s_distance, s_trainIdx, s_imgIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, myBestImgIdx, s_distance, s_trainIdx, s_imgIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = myBestTrainIdx;
-            bestImgIdx[queryIdx] = myBestImgIdx;
-            bestDistance[queryIdx] = myBestDistance;
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestImgIdx[queryIdx] = myBestImgIdx;
+        bestDistance[queryIdx] = myBestDistance;
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-                             const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-                             cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolledCached(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+                         const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+                         cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= 2 * BLOCK_SIZE ? MAX_DESC_LEN : 2 * BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (BLOCK_SIZE * (MAX_DESC_LEN >= 2 * BLOCK_SIZE ? MAX_DESC_LEN : 2 * BLOCK_SIZE) + BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolledCached<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match Unrolled
+///////////////////////////////////////////////////////////////////////////////
+// Match Unrolled
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    __device__ void loopUnrolled(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
-                                 typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
-                                 float& bestDistance, int& bestTrainIdx, int& bestImgIdx)
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+__device__ void loopUnrolled(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
+                             typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
+                             float& bestDistance, int& bestTrainIdx, int& bestImgIdx)
+{
+    for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
     {
-        for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
-        {
-            Dist dist;
+        Dist dist;
 
-            #pragma unroll
-            for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
-            {
-                const int loadX = threadIdx.x + i * BLOCK_SIZE;
+        #pragma unroll
+        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+        {
+            const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-                if (loadX < query.cols)
-                {
-                    T val;
+            if (loadX < query.cols)
+            {
+                T val;
 
-                    ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                    s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
+                ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-                    ForceGlob<T>::Load(train.ptr(min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                    s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-                }
+                ForceGlob<T>::Load(train.ptr(::min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+            }
 
-                __syncthreads();
+            __syncthreads();
 
-                #pragma unroll
-                for (int j = 0; j < BLOCK_SIZE; ++j)
-                    dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+            #pragma unroll
+            for (int j = 0; j < BLOCK_SIZE; ++j)
+                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-                __syncthreads();
-            }
+            __syncthreads();
+        }
 
-            typename Dist::result_type distVal = dist;
+        typename Dist::result_type distVal = dist;
 
-            const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
+        const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
 
-            if (queryIdx < query.rows && trainIdx < train.rows && distVal < bestDistance && mask(queryIdx, trainIdx))
-            {
-                bestImgIdx = imgIdx;
-                bestDistance = distVal;
-                bestTrainIdx = trainIdx;
-            }
+        if (queryIdx < query.rows && trainIdx < train.rows && distVal < bestDistance && mask(queryIdx, trainIdx))
+        {
+            bestImgIdx = imgIdx;
+            bestDistance = distVal;
+            bestTrainIdx = trainIdx;
         }
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
-    __global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int* bestTrainIdx, float* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
+__global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int* bestTrainIdx, float* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        float myBestDistance = numeric_limits<float>::max();
-        int myBestTrainIdx = -1;
+    float myBestDistance = numeric_limits<float>::max();
+    int myBestTrainIdx = -1;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        
-        loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance, myBestTrainIdx, myBestTrainIdx);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    
+    loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance, myBestTrainIdx, myBestTrainIdx);
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, s_distance, s_trainIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, s_distance, s_trainIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = myBestTrainIdx;
-            bestDistance[queryIdx] = myBestDistance;
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestDistance[queryIdx] = myBestDistance;
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                       const DevMem2Di& trainIdx, const DevMem2Df& distance, 
-                       cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                   const DevMem2Di& trainIdx, const DevMem2Df& distance, 
+                   cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
-    __global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, 
-                                  int* bestTrainIdx, int* bestImgIdx, float* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
+__global__ void matchUnrolled(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, 
+                              int* bestTrainIdx, int* bestImgIdx, float* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        float myBestDistance = numeric_limits<float>::max();
-        int myBestTrainIdx = -1;
-        int myBestImgIdx = -1;
+    float myBestDistance = numeric_limits<float>::max();
+    int myBestTrainIdx = -1;
+    int myBestImgIdx = -1;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        Mask m = mask;
-        
-        for (int imgIdx = 0; imgIdx < n; ++imgIdx)
-        {
-            const DevMem2D_<T> train = trains[imgIdx];
-            m.next();
-            loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance, myBestTrainIdx, myBestImgIdx);
-        }
+    Mask m = mask;
+    
+    for (int imgIdx = 0; imgIdx < n; ++imgIdx)
+    {
+        const DevMem2D_<T> train = trains[imgIdx];
+        m.next();
+        loopUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance, myBestTrainIdx, myBestImgIdx);
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        int* s_imgIdxIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    int* s_imgIdxIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, myBestImgIdx, s_distance, s_trainIdx, s_imgIdxIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, myBestImgIdx, s_distance, s_trainIdx, s_imgIdxIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = myBestTrainIdx;
-            bestImgIdx[queryIdx] = myBestImgIdx;
-            bestDistance[queryIdx] = myBestDistance;
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestImgIdx[queryIdx] = myBestImgIdx;
+        bestDistance[queryIdx] = myBestDistance;
     }
+}
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-                       const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-                       cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+                   const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+                   cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match
+///////////////////////////////////////////////////////////////////////////////
+// Match
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    __device__ void loop(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
-                         typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
-                         float& bestDistance, int& bestTrainIdx, int& bestImgIdx)
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+__device__ void loop(int queryIdx, const DevMem2D_<T>& query, int imgIdx, const DevMem2D_<T>& train, const Mask& mask, 
+                     typename Dist::value_type* s_query, typename Dist::value_type* s_train, 
+                     float& bestDistance, int& bestTrainIdx, int& bestImgIdx)
+{
+    for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
     {
-        for (int t = 0, endt = (train.rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; ++t)
-        {
-            Dist dist;
+        Dist dist;
 
-            for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
-            {
-                const int loadX = threadIdx.x + i * BLOCK_SIZE;
+        for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
+        {
+            const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-                if (loadX < query.cols)
-                {
-                    T val;
+            if (loadX < query.cols)
+            {
+                T val;
 
-                    ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                    s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
+                ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-                    ForceGlob<T>::Load(train.ptr(min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                    s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-                }
+                ForceGlob<T>::Load(train.ptr(::min(t * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+            }
 
-                __syncthreads();
+            __syncthreads();
 
-                #pragma unroll
-                for (int j = 0; j < BLOCK_SIZE; ++j)
-                    dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+            #pragma unroll
+            for (int j = 0; j < BLOCK_SIZE; ++j)
+                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-                __syncthreads();
-            }
+            __syncthreads();
+        }
 
-            typename Dist::result_type distVal = dist;
+        typename Dist::result_type distVal = dist;
 
-            const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
+        const int trainIdx = t * BLOCK_SIZE + threadIdx.x;
 
-            if (queryIdx < query.rows && trainIdx < train.rows && distVal < bestDistance && mask(queryIdx, trainIdx))
-            {
-                bestImgIdx = imgIdx;
-                bestDistance = distVal;
-                bestTrainIdx = trainIdx;
-            }
+        if (queryIdx < query.rows && trainIdx < train.rows && distVal < bestDistance && mask(queryIdx, trainIdx))
+        {
+            bestImgIdx = imgIdx;
+            bestDistance = distVal;
+            bestTrainIdx = trainIdx;
         }
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
-    __global__ void match(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int* bestTrainIdx, float* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
+__global__ void match(const DevMem2D_<T> query, const DevMem2D_<T> train, const Mask mask, int* bestTrainIdx, float* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        float myBestDistance = numeric_limits<float>::max();
-        int myBestTrainIdx = -1;
+    float myBestDistance = numeric_limits<float>::max();
+    int myBestTrainIdx = -1;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        
-        loop<BLOCK_SIZE, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance, myBestTrainIdx, myBestTrainIdx);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    
+    loop<BLOCK_SIZE, Dist>(queryIdx, query, 0, train, mask, s_query, s_train, myBestDistance, myBestTrainIdx, myBestTrainIdx);
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, s_distance, s_trainIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, s_distance, s_trainIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = myBestTrainIdx;
-            bestDistance[queryIdx] = myBestDistance;
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestDistance[queryIdx] = myBestDistance;
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-               const DevMem2Di& trainIdx, const DevMem2Df& distance, 
-               cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+           const DevMem2Di& trainIdx, const DevMem2Df& distance, 
+           cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, train, mask, trainIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
-    __global__ void match(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, 
-                          int* bestTrainIdx, int* bestImgIdx, float* bestDistance)
-    {
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
+__global__ void match(const DevMem2D_<T> query, const DevMem2D_<T>* trains, int n, const Mask mask, 
+                      int* bestTrainIdx, int* bestImgIdx, float* bestDistance)
+{
+    extern __shared__ int smem[];
 
-        const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
+    const int queryIdx = blockIdx.x * BLOCK_SIZE + threadIdx.y;
 
-        float myBestDistance = numeric_limits<float>::max();
-        int myBestTrainIdx = -1;
-        int myBestImgIdx = -1;
+    float myBestDistance = numeric_limits<float>::max();
+    int myBestTrainIdx = -1;
+    int myBestImgIdx = -1;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        Mask m = mask;
-        for (int imgIdx = 0; imgIdx < n; ++imgIdx)
-        {
-            const DevMem2D_<T> train = trains[imgIdx];
-            m.next();
-            loop<BLOCK_SIZE, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance, myBestTrainIdx, myBestImgIdx);
-        }
+    Mask m = mask;
+    for (int imgIdx = 0; imgIdx < n; ++imgIdx)
+    {
+        const DevMem2D_<T> train = trains[imgIdx];
+        m.next();
+        loop<BLOCK_SIZE, Dist>(queryIdx, query, imgIdx, train, m, s_query, s_train, myBestDistance, myBestTrainIdx, myBestImgIdx);
+    }
 
-        __syncthreads();
+    __syncthreads();
 
-        float* s_distance = (float*)(smem);
-        int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-        int* s_imgIdxIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
+    float* s_distance = (float*)(smem);
+    int* s_trainIdx = (int*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    int* s_imgIdxIdx = (int*)(smem + 2 * BLOCK_SIZE * BLOCK_SIZE);
 
-        findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, myBestImgIdx, s_distance, s_trainIdx, s_imgIdxIdx);
+    findBestMatch<BLOCK_SIZE>(myBestDistance, myBestTrainIdx, myBestImgIdx, s_distance, s_trainIdx, s_imgIdxIdx);
 
-        if (queryIdx < query.rows && threadIdx.x == 0)
-        {
-            bestTrainIdx[queryIdx] = myBestTrainIdx;
-            bestImgIdx[queryIdx] = myBestImgIdx;
-            bestDistance[queryIdx] = myBestDistance;
-        }
+    if (queryIdx < query.rows && threadIdx.x == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestImgIdx[queryIdx] = myBestImgIdx;
+        bestDistance[queryIdx] = myBestDistance;
     }
+}
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-               const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-               cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(query.rows, BLOCK_SIZE));
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+           const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+           cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    const size_t smemSize = (3 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
-        cudaSafeCall( cudaGetLastError() );
+    match<BLOCK_SIZE, Dist><<<grid, block, smemSize, stream>>>(query, trains, n, mask, trainIdx.data, imgIdx.data, distance.data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match dispatcher
+///////////////////////////////////////////////////////////////////////////////
+// Match dispatcher
 
-    template <typename Dist, typename T, typename Mask> 
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
-                         const DevMem2Di& trainIdx, const DevMem2Df& distance, 
-                         int cc, cudaStream_t stream)
+template <typename Dist, typename T, typename Mask> 
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, const Mask& mask, 
+                     const DevMem2Di& trainIdx, const DevMem2Df& distance, 
+                     int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolledCached<16, 64, Dist>(query, train, mask, trainIdx, distance, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolledCached<16, 128, Dist>(query, train, mask, trainIdx, distance, stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, train, mask, trainIdx, distance, stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, train, mask, trainIdx, distance, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, train, mask, trainIdx, distance, stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, train, mask, trainIdx, distance, stream);
-        }
+        matchUnrolledCached<16, 64, Dist>(query, train, mask, trainIdx, distance, stream);
     }
-
-    template <typename Dist, typename T, typename Mask> 
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
-                         const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-                         int cc, cudaStream_t stream)
+    else if (query.cols <= 128)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolledCached<16, 64, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolledCached<16, 128, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
-        }
+        matchUnrolledCached<16, 128, Dist>(query, train, mask, trainIdx, distance, stream);
     }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match caller
-
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
-                                           const DevMem2Di& trainIdx, const DevMem2Df& distance,
-                                           int cc, cudaStream_t stream)
+    /*else if (query.cols <= 256)
     {
-        if (mask.data)
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), SingleMask(mask), 
-                trainIdx, distance, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), WithOutMask(), 
-                trainIdx, distance, 
-                cc, stream);
-        }
+        matchUnrolled<16, 256, Dist>(query, train, mask, trainIdx, distance, stream);
     }
-
-    template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
-                                           const DevMem2Di& trainIdx, const DevMem2Df& distance, 
-                                           int cc, cudaStream_t stream)
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, train, mask, trainIdx, distance, stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, train, mask, trainIdx, distance, stream);
+    }*/
+    else
     {
-        if (mask.data)
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), SingleMask(mask), 
-                trainIdx, distance, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), WithOutMask(), 
-                trainIdx, distance, 
-                cc, stream);
-        }
+        match<16, Dist>(query, train, mask, trainIdx, distance, stream);
     }
+}
 
-    //template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
-                                                const DevMem2Di& trainIdx, const DevMem2Df& distance, 
-                                                int cc, cudaStream_t stream)
+template <typename Dist, typename T, typename Mask> 
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, const Mask& mask, 
+                     const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+                     int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        if (mask.data)
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), SingleMask(mask), 
-                trainIdx, distance, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), WithOutMask(), 
-                trainIdx, distance, 
-                cc, stream);
-        }
+        matchUnrolledCached<16, 64, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
     }
-
-    template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
-                                           const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-                                           int cc, cudaStream_t stream)
+    else if (query.cols <= 128)
     {
-        if (masks.data)
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), 
-                trainIdx, imgIdx, distance, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), 
-                trainIdx, imgIdx, distance, 
-                cc, stream);
-        }
+        matchUnrolledCached<16, 128, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
+    }
+    /*else if (query.cols <= 256)
+    {
+        matchUnrolled<16, 256, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
+    }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
     }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
+    }*/
+    else
+    {
+        match<16, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
+    }
+}
 
-    template void matchL1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+///////////////////////////////////////////////////////////////////////////////
+// Match caller
 
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
-                                           const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-                                           int cc, cudaStream_t stream)
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
+                                       const DevMem2Di& trainIdx, const DevMem2Df& distance,
+                                       int cc, cudaStream_t stream)
+{
+    if (mask.data)
     {
-        if (masks.data)
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), 
-                trainIdx, imgIdx, distance, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), 
-                trainIdx, imgIdx, distance, 
-                cc, stream);
-        }
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), SingleMask(mask), 
+            trainIdx, distance, 
+            cc, stream);
     }
+    else
+    {
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), WithOutMask(), 
+            trainIdx, distance, 
+            cc, stream);
+    }
+}
+
+template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
+                                       const DevMem2Di& trainIdx, const DevMem2Df& distance, 
+                                       int cc, cudaStream_t stream)
+{
+    if (mask.data)
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), SingleMask(mask), 
+            trainIdx, distance, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), WithOutMask(), 
+            trainIdx, distance, 
+            cc, stream);
+    }
+}
+
+//template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, const DevMem2Db& mask, 
+                                            const DevMem2Di& trainIdx, const DevMem2Df& distance, 
+                                            int cc, cudaStream_t stream)
+{
+    if (mask.data)
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), SingleMask(mask), 
+            trainIdx, distance, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), WithOutMask(), 
+            trainIdx, distance, 
+            cc, stream);
+    }
+}
 
-    //template void matchL2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& maskCollection, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
 
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
-                                                const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
-                                                int cc, cudaStream_t stream)
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
+                                       const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+                                       int cc, cudaStream_t stream)
+{
+    if (masks.data)
     {
-        if (masks.data)
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), 
-                trainIdx, imgIdx, distance, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), 
-                trainIdx, imgIdx, distance, 
-                cc, stream);
-        }
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), 
+            trainIdx, imgIdx, distance, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), 
+            trainIdx, imgIdx, distance, 
+            cc, stream);
     }
+}
+
+template void matchL1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
+                                       const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+                                       int cc, cudaStream_t stream)
+{
+    if (masks.data)
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), 
+            trainIdx, imgIdx, distance, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), 
+            trainIdx, imgIdx, distance, 
+            cc, stream);
+    }
+}
+
+//template void matchL2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& maskCollection, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, 
+                                            const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, 
+                                            int cc, cudaStream_t stream)
+{
+    if (masks.data)
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), 
+            trainIdx, imgIdx, distance, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains.ptr(), trains.cols, WithOutMask(), 
+            trainIdx, imgIdx, distance, 
+            cc, stream);
+    }
+}
+
+template void matchHamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
+
+} // namespace bf_match
 
-    template void matchHamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db& trains, const DevMem2D_<PtrStepb>& masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, int cc, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/bf_radius_match.cu b/modules/gpu/src/cuda/bf_radius_match.cu
index e3500758dd48e89f00dd2a5ec878c9a1d5018b95..519ed7fc0f98a09168e7c779a5e0d9d600d593fe 100644
--- a/modules/gpu/src/cuda/bf_radius_match.cu
+++ b/modules/gpu/src/cuda/bf_radius_match.cu
@@ -45,421 +45,423 @@
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace bf_radius_match
+namespace bf_radius_match {
+
+///////////////////////////////////////////////////////////////////////////////
+// Match Unrolled
+
+template <int BLOCK_SIZE, int MAX_DESC_LEN, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
+__global__ void matchUnrolled(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
+    PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
 {
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match Unrolled
+    #if __CUDA_ARCH__ >= 110
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
-    __global__ void matchUnrolled(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
-        PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
-    {
-        #if __CUDA_ARCH__ >= 110
+    extern __shared__ int smem[];
+
+    const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
+    const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
 
-        extern __shared__ int smem[];
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
-        const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+    Dist dist;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+    {
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-        Dist dist;
+        s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+        s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-        #pragma unroll
-        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
+        if (loadX < query.cols)
         {
-            const int loadX = threadIdx.x + i * BLOCK_SIZE;
+            T val;
 
-            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+            ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-            if (loadX < query.cols)
-            {
-                T val;
+            ForceGlob<T>::Load(train.ptr(::min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+        }
 
-                ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
+        __syncthreads();
 
-                ForceGlob<T>::Load(train.ptr(min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-            }
+        #pragma unroll
+        for (int j = 0; j < BLOCK_SIZE; ++j)
+            dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-            __syncthreads();
+        __syncthreads();
+    }
 
-            #pragma unroll
-            for (int j = 0; j < BLOCK_SIZE; ++j)
-                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+    float distVal = (typename Dist::result_type)dist;
 
-            __syncthreads();
+    if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
+    {
+        unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
+        if (ind < maxCount)
+        {
+            bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
+            if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
+            bestDistance.ptr(queryIdx)[ind] = distVal;
         }
+    }
 
-        float distVal = (typename Dist::result_type)dist;
+    #endif
+}
 
-        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
-        {
-            unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
-            if (ind < maxCount)
-            {
-                bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
-                if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
-                bestDistance.ptr(queryIdx)[ind] = distVal;
-            }
-        }
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-        #endif
-    }
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
+    matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
+        trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
+    cudaSafeCall( cudaGetLastError() );
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}   
 
-        matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
-            trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
-        cudaSafeCall( cudaGetLastError() );
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }   
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        cudaStream_t stream)
+    for (int i = 0; i < n; ++i)
     {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+        const DevMem2D_<T> train = trains[i];
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+        const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-        for (int i = 0; i < n; ++i)
+        if (masks != 0 && masks[i].data)
         {
-            const DevMem2D_<T> train = trains[i];
-
-            const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
-
-            if (masks != 0 && masks[i].data)
-            {
-                matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            else
-            {
-                matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            cudaSafeCall( cudaGetLastError() );
+            matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
         }
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        else
+        {
+            matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
+        }
+        cudaSafeCall( cudaGetLastError() );
     }
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
-    __global__ void match(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
-        PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
-    {
-        #if __CUDA_ARCH__ >= 110
+///////////////////////////////////////////////////////////////////////////////
+// Match
 
-        extern __shared__ int smem[];
+template <int BLOCK_SIZE, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
+__global__ void match(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
+    PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
+{
+    #if __CUDA_ARCH__ >= 110
 
-        const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
-        const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+    extern __shared__ int smem[];
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+    const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
+    const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
 
-        Dist dist;
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
 
-        for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
-        {
-            const int loadX = threadIdx.x + i * BLOCK_SIZE;
+    Dist dist;
+
+    for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
+    {
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+        s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+        s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-            if (loadX < query.cols)
-            {
-                T val;
+        if (loadX < query.cols)
+        {
+            T val;
 
-                ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
+            ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-                ForceGlob<T>::Load(train.ptr(min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-            }
+            ForceGlob<T>::Load(train.ptr(::min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+        }
 
-            __syncthreads();
+        __syncthreads();
 
-            #pragma unroll
-            for (int j = 0; j < BLOCK_SIZE; ++j)
-                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
+        #pragma unroll
+        for (int j = 0; j < BLOCK_SIZE; ++j)
+            dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-            __syncthreads();
-        }
+        __syncthreads();
+    }
 
-        float distVal = (typename Dist::result_type)dist;
+    float distVal = (typename Dist::result_type)dist;
 
-        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
+    if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
+    {
+        unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
+        if (ind < maxCount)
         {
-            unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
-            if (ind < maxCount)
-            {
-                bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
-                if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
-                bestDistance.ptr(queryIdx)[ind] = distVal;
-            }
+            bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
+            if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
+            bestDistance.ptr(queryIdx)[ind] = distVal;
         }
-
-        #endif
     }
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-        const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
+    #endif
+}
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-        match<BLOCK_SIZE, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
-            trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
-        cudaSafeCall( cudaGetLastError() );
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    match<BLOCK_SIZE, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
+        trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
+    cudaSafeCall( cudaGetLastError() );
 
-    template <int BLOCK_SIZE, typename Dist, typename T> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+template <int BLOCK_SIZE, typename Dist, typename T> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
 
-        for (int i = 0; i < n; ++i)
-        {
-            const DevMem2D_<T> train = trains[i];
-
-            const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
-
-            if (masks != 0 && masks[i].data)
-            {
-                match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            else
-            {
-                match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            cudaSafeCall( cudaGetLastError() );
-        }
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    for (int i = 0; i < n; ++i)
+    {
+        const DevMem2D_<T> train = trains[i];
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match dispatcher
+        const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-    template <typename Dist, typename T, typename Mask> 
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
-                         const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-                         int cc, cudaStream_t stream)
-    {
-        if (query.cols <= 64)
-        {
-            matchUnrolled<16, 64, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolled<16, 128, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        /*else if (query.cols <= 256)
+        if (masks != 0 && masks[i].data)
         {
-            matchUnrolled<16, 256, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+            match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
         }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }*/
         else
         {
-            match<16, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+            match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
         }
+        cudaSafeCall( cudaGetLastError() );
     }
 
-    template <typename Dist, typename T> 
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
-                         const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-                         int cc, cudaStream_t stream)
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Match dispatcher
+
+template <typename Dist, typename T, typename Mask> 
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
+                     const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+                     int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolled<16, 64, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolled<16, 128, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-    } 
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    // Radius Match caller
-
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+        matchUnrolled<16, 64, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 128)
     {
-        if (mask.data)
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
+        matchUnrolled<16, 128, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
-
-    template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+    /*else if (query.cols <= 256)
     {
-        if (mask.data)
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
+        matchUnrolled<16, 256, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+    }*/
+    else
+    {
+        match<16, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+    }
+}
 
-    //template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+template <typename Dist, typename T> 
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
+                     const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+                     int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        if (mask.data)
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
+        matchUnrolled<16, 64, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
     }
+    else if (query.cols <= 128)
+    {
+        matchUnrolled<16, 128, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    /*else if (query.cols <= 256)
+    {
+        matchUnrolled<16, 256, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }*/
+    else
+    {
+        match<16, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+} 
 
-    template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+///////////////////////////////////////////////////////////////////////////////
+// Radius Match caller
 
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
     {
-        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
-            trainIdx, imgIdx, distance, nMatches, 
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
+            trainIdx, distance, nMatches, 
             cc, stream);
     }
-
-    template void matchL1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+    else
     {
-        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
-            trainIdx, imgIdx, distance, nMatches, 
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
+            trainIdx, distance, nMatches, 
             cc, stream);
     }
-
-    //template void matchL2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+}
+
+template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
+            trainIdx, distance, nMatches, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
+            trainIdx, distance, nMatches, 
+            cc, stream);
+    }
+}
+
+//template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
+            trainIdx, distance, nMatches, 
+            cc, stream);
+    }
+    else
     {
-        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
-            trainIdx, imgIdx, distance, nMatches, 
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
+            trainIdx, distance, nMatches, 
             cc, stream);
     }
+}
+
+template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
+        trainIdx, imgIdx, distance, nMatches, 
+        cc, stream);
+}
+
+template void matchL1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
+        trainIdx, imgIdx, distance, nMatches, 
+        cc, stream);
+}
+
+//template void matchL2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
+        trainIdx, imgIdx, distance, nMatches, 
+        cc, stream);
+}
+
+template void matchHamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+} // namespace bf_radius_match
 
-    template void matchHamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/bilateral_filter.cu b/modules/gpu/src/cuda/bilateral_filter.cu
index 173c156cf42b4170295ab3dabc7849f2346142eb..4d3d9bcf7789a4f9d6d21e129d670e9d3c68a5cc 100644
--- a/modules/gpu/src/cuda/bilateral_filter.cu
+++ b/modules/gpu/src/cuda/bilateral_filter.cu
@@ -43,191 +43,186 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace bf_krnls
+namespace bilateral_filter {
+
+__constant__ float* ctable_color;
+__constant__ float* ctable_space;
+__constant__ size_t ctable_space_step;
+
+__constant__ int cndisp;
+__constant__ int cradius;
+
+__constant__ short cedge_disc;
+__constant__ short cmax_disc;
+
+void load_constants(float* table_color, DevMem2Df table_space, int ndisp, int radius, short edge_disc, short max_disc)
 {
-    __constant__ float* ctable_color;
-    __constant__ float* ctable_space;
-    __constant__ size_t ctable_space_step;
+    cudaSafeCall( cudaMemcpyToSymbol(ctable_color, &table_color, sizeof(table_color)) );
+    cudaSafeCall( cudaMemcpyToSymbol(ctable_space, &table_space.data, sizeof(table_space.data)) );
+    size_t table_space_step = table_space.step / sizeof(float);
+    cudaSafeCall( cudaMemcpyToSymbol(ctable_space_step, &table_space_step, sizeof(size_t)) );
 
-    __constant__ int cndisp;
-    __constant__ int cradius;
+    cudaSafeCall( cudaMemcpyToSymbol(cndisp, &ndisp, sizeof(int)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cradius, &radius, sizeof(int)) );
 
-    __constant__ short cedge_disc;
-    __constant__ short cmax_disc;
+    cudaSafeCall( cudaMemcpyToSymbol(cedge_disc, &edge_disc, sizeof(short)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_disc, &max_disc, sizeof(short)) );
 }
 
-namespace cv { namespace gpu { namespace bf 
+template <int channels>
+struct DistRgbMax
 {
-    void load_constants(float* table_color, const DevMem2Df& table_space, int ndisp, int radius, short edge_disc, short max_disc)
+    static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
     {
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::ctable_color, &table_color, sizeof(table_color)) );
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::ctable_space, &table_space.data, sizeof(table_space.data)) );
-        size_t table_space_step = table_space.step / sizeof(float);
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::ctable_space_step, &table_space_step, sizeof(size_t)) );
-
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cndisp, &ndisp, sizeof(int)) );
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cradius, &radius, sizeof(int)) );
-
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cedge_disc, &edge_disc, sizeof(short)) );
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cmax_disc, &max_disc, sizeof(short)) );
+        uchar x = ::abs(a[0] - b[0]);
+        uchar y = ::abs(a[1] - b[1]);
+        uchar z = ::abs(a[2] - b[2]);
+        return (::max(::max(x, y), z));
     }
-}}}
+};
 
-namespace bf_krnls
+template <>
+struct DistRgbMax<1>
 {
-    template <int channels>
-    struct DistRgbMax
+    static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
     {
-        static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
-        {
-            uchar x = abs(a[0] - b[0]);
-            uchar y = abs(a[1] - b[1]);
-            uchar z = abs(a[2] - b[2]);
-            return (max(max(x, y), z));
-        }
-    };
+        return ::abs(a[0] - b[0]);
+    }
+};
 
-    template <>
-    struct DistRgbMax<1>
-    {
-        static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
-        {
-            return abs(a[0] - b[0]);
-        }
-    };
+template <int channels, typename T>
+__global__ void bilateral_filter(int t, T* disp, size_t disp_step, const uchar* img, size_t img_step, int h, int w)
+{
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
 
-    template <int channels, typename T>
-    __global__ void bilateral_filter(int t, T* disp, size_t disp_step, const uchar* img, size_t img_step, int h, int w)
-    {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
+    T dp[5];
 
-        T dp[5];
+    if (y > 0 && y < h - 1 && x > 0 && x < w - 1)
+    {
+        dp[0] = *(disp + (y  ) * disp_step + x + 0);
+        dp[1] = *(disp + (y-1) * disp_step + x + 0);
+        dp[2] = *(disp + (y  ) * disp_step + x - 1);
+        dp[3] = *(disp + (y+1) * disp_step + x + 0);
+        dp[4] = *(disp + (y  ) * disp_step + x + 1);
 
-        if (y > 0 && y < h - 1 && x > 0 && x < w - 1)
+        if(::abs(dp[1] - dp[0]) >= cedge_disc || ::abs(dp[2] - dp[0]) >= cedge_disc || ::abs(dp[3] - dp[0]) >= cedge_disc || ::abs(dp[4] - dp[0]) >= cedge_disc)            
         {
-            dp[0] = *(disp + (y  ) * disp_step + x + 0);
-            dp[1] = *(disp + (y-1) * disp_step + x + 0);
-            dp[2] = *(disp + (y  ) * disp_step + x - 1);
-            dp[3] = *(disp + (y+1) * disp_step + x + 0);
-            dp[4] = *(disp + (y  ) * disp_step + x + 1);
+            const int ymin = ::max(0, y - cradius);
+            const int xmin = ::max(0, x - cradius);
+            const int ymax = ::min(h - 1, y + cradius);
+            const int xmax = ::min(w - 1, x + cradius);
 
-            if(abs(dp[1] - dp[0]) >= cedge_disc || abs(dp[2] - dp[0]) >= cedge_disc || abs(dp[3] - dp[0]) >= cedge_disc || abs(dp[4] - dp[0]) >= cedge_disc)            
-            {
-                const int ymin = max(0, y - cradius);
-                const int xmin = max(0, x - cradius);
-                const int ymax = min(h - 1, y + cradius);
-                const int xmax = min(w - 1, x + cradius);
+            float cost[] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
 
-                float cost[] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+            const uchar* ic = img + y * img_step + channels * x;
 
-                const uchar* ic = img + y * img_step + channels * x;
+            for(int yi = ymin; yi <= ymax; yi++)
+            {
+                const T* disp_y = disp + yi * disp_step;
 
-                for(int yi = ymin; yi <= ymax; yi++)
+                for(int xi = xmin; xi <= xmax; xi++)
                 {
-                    const T* disp_y = disp + yi * disp_step;
-
-                    for(int xi = xmin; xi <= xmax; xi++)
-                    {
-                        const uchar* in = img + yi * img_step + channels * xi;
+                    const uchar* in = img + yi * img_step + channels * xi;
 
-                        uchar dist_rgb = DistRgbMax<channels>::calc(in, ic);
+                    uchar dist_rgb = DistRgbMax<channels>::calc(in, ic);
 
-                        const float weight = ctable_color[dist_rgb] * (ctable_space + abs(y-yi)* ctable_space_step)[abs(x-xi)];
+                    const float weight = ctable_color[dist_rgb] * (ctable_space + ::abs(y-yi)* ctable_space_step)[::abs(x-xi)];
 
-                        const T disp_reg = disp_y[xi];
+                    const T disp_reg = disp_y[xi];
 
-                        cost[0] += min(cmax_disc, abs(disp_reg - dp[0])) * weight;
-                        cost[1] += min(cmax_disc, abs(disp_reg - dp[1])) * weight;
-                        cost[2] += min(cmax_disc, abs(disp_reg - dp[2])) * weight;
-                        cost[3] += min(cmax_disc, abs(disp_reg - dp[3])) * weight;
-                        cost[4] += min(cmax_disc, abs(disp_reg - dp[4])) * weight;
-                    }
+                    cost[0] += ::min(cmax_disc, ::abs(disp_reg - dp[0])) * weight;
+                    cost[1] += ::min(cmax_disc, ::abs(disp_reg - dp[1])) * weight;
+                    cost[2] += ::min(cmax_disc, ::abs(disp_reg - dp[2])) * weight;
+                    cost[3] += ::min(cmax_disc, ::abs(disp_reg - dp[3])) * weight;
+                    cost[4] += ::min(cmax_disc, ::abs(disp_reg - dp[4])) * weight;
                 }
+            }
 
-                float minimum = numeric_limits<float>::max();
-                int id = 0;
+            float minimum = numeric_limits<float>::max();
+            int id = 0;
 
-                if (cost[0] < minimum)
-                {
-                    minimum = cost[0];
-                    id = 0;
-                }
-                if (cost[1] < minimum)
-                {
-                    minimum = cost[1];
-                    id = 1;
-                }
-                if (cost[2] < minimum)
-                {
-                    minimum = cost[2];
-                    id = 2;
-                }
-                if (cost[3] < minimum)
-                {
-                    minimum = cost[3];
-                    id = 3;
-                }
-                if (cost[4] < minimum)
-                {
-                    minimum = cost[4];
-                    id = 4;
-                }
-
-                *(disp + y * disp_step + x) = dp[id];
+            if (cost[0] < minimum)
+            {
+                minimum = cost[0];
+                id = 0;
             }
+            if (cost[1] < minimum)
+            {
+                minimum = cost[1];
+                id = 1;
+            }
+            if (cost[2] < minimum)
+            {
+                minimum = cost[2];
+                id = 2;
+            }
+            if (cost[3] < minimum)
+            {
+                minimum = cost[3];
+                id = 3;
+            }
+            if (cost[4] < minimum)
+            {
+                minimum = cost[4];
+                id = 4;
+            }
+
+            *(disp + y * disp_step + x) = dp[id];
         }
     }
 }
 
-namespace cv { namespace gpu { namespace bf 
+template <typename T>     
+void bilateral_filter_caller(DevMem2D_<T> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream)
 {
-    template <typename T>     
-    void bilateral_filter_caller(const DevMem2D_<T>& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-        grid.x = divUp(disp.cols, threads.x << 1);
-        grid.y = divUp(disp.rows, threads.y);
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+    grid.x = divUp(disp.cols, threads.x << 1);
+    grid.y = divUp(disp.rows, threads.y);
 
-        switch (channels)
+    switch (channels)
+    {
+    case 1:
+        for (int i = 0; i < iters; ++i)
         {
-        case 1:
-            for (int i = 0; i < iters; ++i)
-            {
-                bf_krnls::bilateral_filter<1><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-                bf_krnls::bilateral_filter<1><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-            }
-            break;
-        case 3:
-            for (int i = 0; i < iters; ++i)
-            {
-                bf_krnls::bilateral_filter<3><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-                bf_krnls::bilateral_filter<3><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-            }
-            break;
-        default:
-            cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
+            bilateral_filter<1><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
+
+            bilateral_filter<1><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
         }
+        break;
+    case 3:
+        for (int i = 0; i < iters; ++i)
+        {
+            bilateral_filter<3><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
 
-        if (stream != 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+            bilateral_filter<3><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
+        }
+        break;
+    default:
+        cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
     }
 
-    void bilateral_filter_gpu(const DevMem2Db& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream)
-    {
-        bilateral_filter_caller(disp, img, channels, iters, stream);
-    }
+    if (stream != 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    void bilateral_filter_gpu(const DevMem2D_<short>& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream)
-    {
-        bilateral_filter_caller(disp, img, channels, iters, stream);
-    }
-}}}
+void bilateral_filter_gpu(DevMem2Db disp, DevMem2Db img, int channels, int iters, cudaStream_t stream)
+{
+    bilateral_filter_caller(disp, img, channels, iters, stream);
+}
+
+void bilateral_filter_gpu(DevMem2D_<short> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream)
+{
+    bilateral_filter_caller(disp, img, channels, iters, stream);
+}
+
+} // namespace bilateral_filter
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/blend.cu b/modules/gpu/src/cuda/blend.cu
index 4b29a70509923e91d944768770ccaf0ded7cbfff..fca1b961ed81a2be183736a5e269a329455d39ad 100644
--- a/modules/gpu/src/cuda/blend.cu
+++ b/modules/gpu/src/cuda/blend.cu
@@ -42,81 +42,77 @@
 
 #include "internal_shared.hpp"
 
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu 
+namespace blend {
+
+template <typename T>
+__global__ void blendLinearKernel(int rows, int cols, int cn, const PtrStep<T> img1, const PtrStep<T> img2,
+                                  const PtrStepf weights1, const PtrStepf weights2, PtrStep<T> result)
 {
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-    template <typename T>
-    __global__ void blendLinearKernel(int rows, int cols, int cn, const PtrStep<T> img1, const PtrStep<T> img2,
-                                      const PtrStepf weights1, const PtrStepf weights2, PtrStep<T> result)
+    if (y < rows && x < cols)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
+        int x_ = x / cn;
+        float w1 = weights1.ptr(y)[x_];
+        float w2 = weights2.ptr(y)[x_];
+        T p1 = img1.ptr(y)[x];
+        T p2 = img2.ptr(y)[x];
+        result.ptr(y)[x] = (p1 * w1 + p2 * w2) / (w1 + w2 + 1e-5f);
+    }
+}	
 
-        if (y < rows && x < cols)
-        {
-            int x_ = x / cn;
-            float w1 = weights1.ptr(y)[x_];
-            float w2 = weights2.ptr(y)[x_];
-            T p1 = img1.ptr(y)[x];
-            T p2 = img2.ptr(y)[x];
-            result.ptr(y)[x] = (p1 * w1 + p2 * w2) / (w1 + w2 + 1e-5f);
-        }
-    }	
+template <typename T>
+void blendLinearCaller(int rows, int cols, int cn, PtrStep<T> img1, PtrStep<T> img2, PtrStepf weights1, PtrStepf weights2, PtrStep<T> result, cudaStream_t stream)
+{
+    dim3 threads(16, 16);
+    dim3 grid(divUp(cols * cn, threads.x), divUp(rows, threads.y));
+    
+    blendLinearKernel<<<grid, threads, 0, stream>>>(rows, cols * cn, cn, img1, img2, weights1, weights2, result);
+    cudaSafeCall( cudaGetLastError() );
 
-    template <typename T>
-    void blendLinearCaller(int rows, int cols, int cn, const PtrStep<T>& img1, const PtrStep<T>& img2, 
-                           const PtrStepf& weights1, const PtrStepf& weights2, PtrStep<T> result, cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(cols * cn, threads.x), divUp(rows, threads.y));
-        
-        blendLinearKernel<<<grid, threads, 0, stream>>>(rows, cols * cn, cn, img1, img2, weights1, weights2, result);
-        cudaSafeCall( cudaGetLastError() );
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+template void blendLinearCaller<uchar>(int, int, int, PtrStep<uchar>, PtrStep<uchar>, PtrStepf, PtrStepf, PtrStep<uchar>, cudaStream_t stream);
+template void blendLinearCaller<float>(int, int, int, PtrStep<float>, PtrStep<float>, PtrStepf, PtrStepf, PtrStep<float>, cudaStream_t stream);
 
-    template void blendLinearCaller<uchar>(int, int, int, const PtrStep<uchar>&, const PtrStep<uchar>&, 
-                                           const PtrStepf&, const PtrStepf&, PtrStep<uchar>, cudaStream_t stream);
-    template void blendLinearCaller<float>(int, int, int, const PtrStep<float>&, const PtrStep<float>&, 
-                                           const PtrStepf&, const PtrStepf&, PtrStep<float>, cudaStream_t stream);
 
+__global__ void blendLinearKernel8UC4(int rows, int cols, const PtrStepb img1, const PtrStepb img2,
+                                      const PtrStepf weights1, const PtrStepf weights2, PtrStepb result)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-    __global__ void blendLinearKernel8UC4(int rows, int cols, const PtrStepb img1, const PtrStepb img2,
-                                          const PtrStepf weights1, const PtrStepf weights2, PtrStepb result)
+    if (y < rows && x < cols)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (y < rows && x < cols)
-        {
-            float w1 = weights1.ptr(y)[x];
-            float w2 = weights2.ptr(y)[x];
-            float sum_inv = 1.f / (w1 + w2 + 1e-5f);
-            w1 *= sum_inv;
-            w2 *= sum_inv;
-            uchar4 p1 = ((const uchar4*)img1.ptr(y))[x];
-            uchar4 p2 = ((const uchar4*)img2.ptr(y))[x];
-            ((uchar4*)result.ptr(y))[x] = make_uchar4(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2,
-                                                      p1.z * w1 + p2.z * w2, p1.w * w1 + p2.w * w2);
-        }
+        float w1 = weights1.ptr(y)[x];
+        float w2 = weights2.ptr(y)[x];
+        float sum_inv = 1.f / (w1 + w2 + 1e-5f);
+        w1 *= sum_inv;
+        w2 *= sum_inv;
+        uchar4 p1 = ((const uchar4*)img1.ptr(y))[x];
+        uchar4 p2 = ((const uchar4*)img2.ptr(y))[x];
+        ((uchar4*)result.ptr(y))[x] = make_uchar4(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2,
+                                                  p1.z * w1 + p2.z * w2, p1.w * w1 + p2.w * w2);
     }
+}
 
+void blendLinearCaller8UC4(int rows, int cols, PtrStepb img1, PtrStepb img2, PtrStepf weights1, PtrStepf weights2, PtrStepb result, cudaStream_t stream)
+{
+    dim3 threads(16, 16);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+    
+    blendLinearKernel8UC4<<<grid, threads, 0, stream>>>(rows, cols, img1, img2, weights1, weights2, result);
+    cudaSafeCall( cudaGetLastError() );
 
-    void blendLinearCaller8UC4(int rows, int cols, const PtrStepb& img1, const PtrStepb& img2, 
-                               const PtrStepf& weights1, const PtrStepf& weights2, PtrStepb result, cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
-        
-        blendLinearKernel8UC4<<<grid, threads, 0, stream>>>(rows, cols, img1, img2, weights1, weights2, result);
-        cudaSafeCall( cudaGetLastError() );
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+} // namespace blend 
 
-}}
\ No newline at end of file
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/calib3d.cu b/modules/gpu/src/cuda/calib3d.cu
index 2a30393817635cd635e00e130520a4f3482a48df..1cdf191b0380c1f7891977e121cee4c8dc77a87f 100644
--- a/modules/gpu/src/cuda/calib3d.cu
+++ b/modules/gpu/src/cuda/calib3d.cu
@@ -44,153 +44,149 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 
-#define SOLVE_PNP_RANSAC_MAX_NUM_ITERS 200
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-using namespace cv::gpu::device;
+#define SOLVE_PNP_RANSAC_MAX_NUM_ITERS 200
 
-namespace cv { namespace gpu
+namespace transform_points
 {
-    namespace transform_points
-    {
-        __constant__ float3 crot0;
-        __constant__ float3 crot1;
-        __constant__ float3 crot2;
-        __constant__ float3 ctransl;
+    __constant__ float3 crot0;
+    __constant__ float3 crot1;
+    __constant__ float3 crot2;
+    __constant__ float3 ctransl;
 
-        struct TransformOp : unary_function<float3, float3>
-        {
-            __device__ __forceinline__ float3 operator()(const float3& p) const
-            {
-                return make_float3(
-                        crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
-                        crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
-                        crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
-            }
-        };
-
-        void call(const DevMem2D_<float3> src, const float* rot,
-                  const float* transl, DevMem2D_<float3> dst,
-                  cudaStream_t stream)
+    struct TransformOp : unary_function<float3, float3>
+    {
+        __device__ __forceinline__ float3 operator()(const float3& p) const
         {
-            cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
-            transform(src, dst, TransformOp(), stream);
+            return make_float3(
+                    crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
+                    crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
+                    crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
         }
-    } // namespace transform_points
-
+    };
 
-    namespace project_points
+    void call(const DevMem2D_<float3> src, const float* rot,
+              const float* transl, DevMem2D_<float3> dst,
+              cudaStream_t stream)
     {
-        __constant__ float3 crot0;
-        __constant__ float3 crot1;
-        __constant__ float3 crot2;
-        __constant__ float3 ctransl;
-        __constant__ float3 cproj0;
-        __constant__ float3 cproj1;
-
-        struct ProjectOp : unary_function<float3, float3>
-        {
-            __device__ __forceinline__ float2 operator()(const float3& p) const
-            {
-                // Rotate and translate in 3D
-                float3 t = make_float3(
-                        crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
-                        crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
-                        crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
-                // Project on 2D plane
-                return make_float2(
-                        (cproj0.x * t.x + cproj0.y * t.y) / t.z + cproj0.z,
-                        (cproj1.x * t.x + cproj1.y * t.y) / t.z + cproj1.z);
-            }
-        };
-
-        void call(const DevMem2D_<float3> src, const float* rot,
-                  const float* transl, const float* proj, DevMem2D_<float2> dst,
-                  cudaStream_t stream)
+        cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
+        OPENCV_DEVICE_NAMESPACE_ transform(src, dst, TransformOp(), stream);
+    }
+} // namespace transform_points
+
+namespace project_points
+{
+    __constant__ float3 crot0;
+    __constant__ float3 crot1;
+    __constant__ float3 crot2;
+    __constant__ float3 ctransl;
+    __constant__ float3 cproj0;
+    __constant__ float3 cproj1;
+
+    struct ProjectOp : unary_function<float3, float3>
+    {
+        __device__ __forceinline__ float2 operator()(const float3& p) const
         {
-            cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(cproj0, proj, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(cproj1, proj + 3, sizeof(float) * 3));
-            transform(src, dst, ProjectOp(), stream);
+            // Rotate and translate in 3D
+            float3 t = make_float3(
+                    crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
+                    crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
+                    crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
+            // Project on 2D plane
+            return make_float2(
+                    (cproj0.x * t.x + cproj0.y * t.y) / t.z + cproj0.z,
+                    (cproj1.x * t.x + cproj1.y * t.y) / t.z + cproj1.z);
         }
-    } // namespace project_points
+    };
 
+    void call(const DevMem2D_<float3> src, const float* rot,
+              const float* transl, const float* proj, DevMem2D_<float2> dst,
+              cudaStream_t stream)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(cproj0, proj, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(cproj1, proj + 3, sizeof(float) * 3));
+        OPENCV_DEVICE_NAMESPACE_ transform(src, dst, ProjectOp(), stream);
+    }
+} // namespace project_points
+
+namespace solve_pnp_ransac
+{
+    __constant__ float3 crot_matrices[SOLVE_PNP_RANSAC_MAX_NUM_ITERS * 3];
+    __constant__ float3 ctransl_vectors[SOLVE_PNP_RANSAC_MAX_NUM_ITERS];
 
-    namespace solve_pnp_ransac
+    int maxNumIters()
     {
-        __constant__ float3 crot_matrices[SOLVE_PNP_RANSAC_MAX_NUM_ITERS * 3];
-        __constant__ float3 ctransl_vectors[SOLVE_PNP_RANSAC_MAX_NUM_ITERS];
+        return SOLVE_PNP_RANSAC_MAX_NUM_ITERS;
+    }
 
-        int maxNumIters()
-        {
-            return SOLVE_PNP_RANSAC_MAX_NUM_ITERS;
-        }
+    __device__ __forceinline__ float sqr(float x)
+    {
+        return x * x;
+    }
+
+    __global__ void computeHypothesisScoresKernel(
+            const int num_points, const float3* object, const float2* image,
+            const float dist_threshold, int* g_num_inliers)
+    {
+        const float3* const &rot_mat = crot_matrices + blockIdx.x * 3;
+        const float3 &transl_vec = ctransl_vectors[blockIdx.x];
+        int num_inliers = 0;
 
-        __device__ __forceinline__ float sqr(float x)
+        for (int i = threadIdx.x; i < num_points; i += blockDim.x)
         {
-            return x * x;
+            float3 p = object[i];
+            p = make_float3(
+                    rot_mat[0].x * p.x + rot_mat[0].y * p.y + rot_mat[0].z * p.z + transl_vec.x,
+                    rot_mat[1].x * p.x + rot_mat[1].y * p.y + rot_mat[1].z * p.z + transl_vec.y,
+                    rot_mat[2].x * p.x + rot_mat[2].y * p.y + rot_mat[2].z * p.z + transl_vec.z);
+            p.x /= p.z;
+            p.y /= p.z;
+            float2 image_p = image[i];
+            if (sqr(p.x - image_p.x) + sqr(p.y - image_p.y) < dist_threshold)
+                ++num_inliers;
         }
 
-        __global__ void computeHypothesisScoresKernel(
-                const int num_points, const float3* object, const float2* image,
-                const float dist_threshold, int* g_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)
         {
-            const float3* const &rot_mat = crot_matrices + blockIdx.x * 3;
-            const float3 &transl_vec = ctransl_vectors[blockIdx.x];
-            int num_inliers = 0;
-
-            for (int i = threadIdx.x; i < num_points; i += blockDim.x)
-            {
-                float3 p = object[i];
-                p = make_float3(
-                        rot_mat[0].x * p.x + rot_mat[0].y * p.y + rot_mat[0].z * p.z + transl_vec.x,
-                        rot_mat[1].x * p.x + rot_mat[1].y * p.y + rot_mat[1].z * p.z + transl_vec.y,
-                        rot_mat[2].x * p.x + rot_mat[2].y * p.y + rot_mat[2].z * p.z + transl_vec.z);
-                p.x /= p.z;
-                p.y /= p.z;
-                float2 image_p = image[i];
-                if (sqr(p.x - image_p.x) + sqr(p.y - image_p.y) < dist_threshold)
-                    ++num_inliers;
-            }
-
-            extern __shared__ float s_num_inliers[];
-            s_num_inliers[threadIdx.x] = num_inliers;
+            if (threadIdx.x < step)
+                s_num_inliers[threadIdx.x] += s_num_inliers[threadIdx.x + step];
             __syncthreads();
-
-            for (int step = blockDim.x / 2; step > 0; step >>= 1)
-            {
-                if (threadIdx.x < step)
-                    s_num_inliers[threadIdx.x] += s_num_inliers[threadIdx.x + step];
-                __syncthreads();
-            }
-
-            if (threadIdx.x == 0)
-                g_num_inliers[blockIdx.x] = s_num_inliers[0];
         }
 
-        void computeHypothesisScores(
-                const int num_hypotheses, const int num_points, const float* rot_matrices,
-                const float3* transl_vectors, const float3* object, const float2* image,
-                const float dist_threshold, int* hypothesis_scores)
-        {
-            cudaSafeCall(cudaMemcpyToSymbol(crot_matrices, rot_matrices, num_hypotheses * 3 * sizeof(float3)));
-            cudaSafeCall(cudaMemcpyToSymbol(ctransl_vectors, transl_vectors, num_hypotheses * sizeof(float3)));
+        if (threadIdx.x == 0)
+            g_num_inliers[blockIdx.x] = s_num_inliers[0];
+    }
 
-            dim3 threads(256);
-            dim3 grid(num_hypotheses);
-            int smem_size = threads.x * sizeof(float);
+    void computeHypothesisScores(
+            const int num_hypotheses, const int num_points, const float* rot_matrices,
+            const float3* transl_vectors, const float3* object, const float2* image,
+            const float dist_threshold, int* hypothesis_scores)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(crot_matrices, rot_matrices, num_hypotheses * 3 * sizeof(float3)));
+        cudaSafeCall(cudaMemcpyToSymbol(ctransl_vectors, transl_vectors, num_hypotheses * sizeof(float3)));
 
-            computeHypothesisScoresKernel<<<grid, threads, smem_size>>>(
-                    num_points, object, image, dist_threshold, hypothesis_scores);
-            cudaSafeCall( cudaGetLastError() );
+        dim3 threads(256);
+        dim3 grid(num_hypotheses);
+        int smem_size = threads.x * sizeof(float);
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    } // namespace solvepnp_ransac
+        computeHypothesisScoresKernel<<<grid, threads, smem_size>>>(
+                num_points, object, image, dist_threshold, hypothesis_scores);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+} // namespace solvepnp_ransac
 
-}} // namespace cv { namespace gpu
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/canny.cu b/modules/gpu/src/cuda/canny.cu
index 4ea26fcb095f42deab26edd48ff7b5b07006919e..0c0f5d9a2c887cc9203a82e224ca1b623cbfdd08 100644
--- a/modules/gpu/src/cuda/canny.cu
+++ b/modules/gpu/src/cuda/canny.cu
@@ -44,339 +44,370 @@
 #include <algorithm>
 #include "internal_shared.hpp"
 
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace canny
+namespace canny {
+
+__global__ void calcSobelRowPass(const PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
 {
-    __global__ void calcSobelRowPass(const PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
-    {
-        __shared__ int smem[16][18];
+    __shared__ int smem[16][18];
 
-        const int j = blockIdx.x * blockDim.x + threadIdx.x;
-        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+    const int j = blockIdx.x * blockDim.x + threadIdx.x;
+    const int i = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (i < rows)
+    if (i < rows)
+    {
+        smem[threadIdx.y][threadIdx.x + 1] = src.ptr(i)[j];
+        if (threadIdx.x == 0)
         {
-            smem[threadIdx.y][threadIdx.x + 1] = src.ptr(i)[j];
-            if (threadIdx.x == 0)
-            {
-                smem[threadIdx.y][0] = src.ptr(i)[max(j - 1, 0)];
-                smem[threadIdx.y][17] = src.ptr(i)[min(j + 16, cols - 1)];
-            }
-            __syncthreads();
+            smem[threadIdx.y][0] = src.ptr(i)[::max(j - 1, 0)];
+            smem[threadIdx.y][17] = src.ptr(i)[::min(j + 16, cols - 1)];
+        }
+        __syncthreads();
 
-            if (j < cols)
-            {
-                dx_buf.ptr(i)[j] = -smem[threadIdx.y][threadIdx.x] + smem[threadIdx.y][threadIdx.x + 2];
-                dy_buf.ptr(i)[j] = smem[threadIdx.y][threadIdx.x] + 2 * smem[threadIdx.y][threadIdx.x + 1] + smem[threadIdx.y][threadIdx.x + 2];
-            }
+        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];
         }
     }
+}
 
-    void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        calcSobelRowPass<<<grid, block>>>(src, dx_buf, dy_buf, rows, cols);
-        cudaSafeCall( cudaGetLastError() );
+    calcSobelRowPass<<<grid, block>>>(src, dx_buf, dy_buf, rows, cols);
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
+    cudaSafeCall(cudaThreadSynchronize());
+}
 
-    struct L1
+struct L1
+{
+    static __device__ __forceinline__ float calc(int x, int y)
     {
-        static __device__ __forceinline__ float calc(int x, int y)
-        {
-            return abs(x) + abs(y);
-        }
-    };
-    struct L2
+        return ::abs(x) + ::abs(y);
+    }
+};
+struct L2
+{
+    static __device__ __forceinline__ float calc(int x, int y)
     {
-        static __device__ __forceinline__ float calc(int x, int y)
-        {
-            return sqrtf(x * x + y * 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];
+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;
+    const int j = blockIdx.x * blockDim.x + threadIdx.x;
+    const int i = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (j < cols)
+    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[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];
+            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();
+            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];
+        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;
+            dx.ptr(i)[j] = x;
+            dy.ptr(i)[j] = y;
 
-                mag.ptr(i + 1)[j + 1] = Norm::calc(x, y);
-            }
+            mag.ptr(i + 1)[j + 1] = Norm::calc(x, y);
         }
     }
+}
 
-    void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        if (L2Grad)
-            calcMagnitude<L2><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
-        else
-            calcMagnitude<L1><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+    if (L2Grad)
+        calcMagnitude<L2><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+    else
+        calcMagnitude<L1><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
 
-        cudaSafeCall( cudaGetLastError() );
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
+    cudaSafeCall(cudaThreadSynchronize());
+}
 
-    template <typename Norm> __global__ void calcMagnitude(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
-    {
-        const int j = blockIdx.x * blockDim.x + threadIdx.x;
-        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename Norm> __global__ void calcMagnitude(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
+{
+    const int j = blockIdx.x * blockDim.x + threadIdx.x;
+    const int i = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (i < rows && j < cols)
-            mag.ptr(i + 1)[j + 1] = Norm::calc(dx.ptr(i)[j], dy.ptr(i)[j]);
-    }
+    if (i < rows && j < cols)
+        mag.ptr(i + 1)[j + 1] = Norm::calc(dx.ptr(i)[j], dy.ptr(i)[j]);
+}
 
-    void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        if (L2Grad)
-            calcMagnitude<L2><<<grid, block>>>(dx, dy, mag, rows, cols);
-        else
-            calcMagnitude<L1><<<grid, block>>>(dx, dy, mag, rows, cols);
+    if (L2Grad)
+        calcMagnitude<L2><<<grid, block>>>(dx, dy, mag, rows, cols);
+    else
+        calcMagnitude<L1><<<grid, block>>>(dx, dy, mag, rows, cols);
 
-        cudaSafeCall( cudaGetLastError() );
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
+    cudaSafeCall(cudaThreadSynchronize());
+}
 
 //////////////////////////////////////////////////////////////////////////////////////////
-        
+    
 #define CANNY_SHIFT 15
 #define TG22        (int)(0.4142135623730950488016887242097*(1<<CANNY_SHIFT) + 0.5)
 
-    __global__ void calcMap(const PtrStepi dx, const PtrStepi dy, const PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
-    {
-        __shared__ float smem[18][18];
+__global__ void calcMap(const PtrStepi dx, const PtrStepi dy, const PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+{
+    __shared__ float smem[18][18];
 
-        const int j = blockIdx.x * 16 + threadIdx.x;
-        const int i = blockIdx.y * 16 + threadIdx.y;
+    const int 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;
+    const int tid = threadIdx.y * 16 + threadIdx.x;
+    const int lx = tid % 18;
+    const int ly = tid / 18;
 
-        if (ly < 14)
-            smem[ly][lx] = mag.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+    if (ly < 14)
+        smem[ly][lx] = mag.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
 
-        if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
-            smem[ly + 14][lx] = mag.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
+    if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
+        smem[ly + 14][lx] = mag.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
 
-        __syncthreads();
+    __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];
+    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);
+        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;
+        // 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);
+        if (m > low_thresh)
+        {
+            const int tg22x = x * TG22;
+            const int tg67x = tg22x + ((x + x) << CANNY_SHIFT);
 
-                y <<= CANNY_SHIFT;
+            y <<= CANNY_SHIFT;
 
-                if (y < tg22x)
-                {
-                    if (m > smem[threadIdx.y + 1][threadIdx.x] && m >= smem[threadIdx.y + 1][threadIdx.x + 2])
-                        edge_type = 1 + (int)(m > high_thresh);
-                }
-                else if( y > tg67x )
-                {
-                    if (m > smem[threadIdx.y][threadIdx.x + 1] && m >= smem[threadIdx.y + 2][threadIdx.x + 1])
-                        edge_type = 1 + (int)(m > high_thresh);
-                }
-                else
-                {
-                    if (m > smem[threadIdx.y][threadIdx.x + 1 - s] && m > smem[threadIdx.y + 2][threadIdx.x + 1 + s])
-                        edge_type = 1 + (int)(m > high_thresh);
-                }
+            if (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;
         }
+        
+        map.ptr(i + 1)[j + 1] = edge_type;
     }
+}
 
 #undef CANNY_SHIFT
 #undef TG22
 
-    void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        calcMap<<<grid, block>>>(dx, dy, mag, map, rows, cols, low_thresh, high_thresh);
-        cudaSafeCall( cudaGetLastError() );
+    calcMap<<<grid, block>>>(dx, dy, mag, map, rows, cols, low_thresh, high_thresh);
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
+    cudaSafeCall(cudaThreadSynchronize());
+}
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-    __device__ unsigned int counter = 0;
-
-    __global__ void edgesHysteresisLocal(PtrStepi map, ushort2* st, int rows, int cols)
-    {
-        #if __CUDA_ARCH__ >= 120
-
-        __shared__ int smem[18][18];
+__device__ unsigned int counter = 0;
 
-        const int j = blockIdx.x * 16 + threadIdx.x;
-        const int i = blockIdx.y * 16 + threadIdx.y;
+__global__ void edgesHysteresisLocal(PtrStepi map, ushort2* st, int rows, int cols)
+{
+    #if __CUDA_ARCH__ >= 120
 
-        const int tid = threadIdx.y * 16 + threadIdx.x;
-        const int lx = tid % 18;
-        const int ly = tid / 18; 
+    __shared__ int smem[18][18];
 
-        if (ly < 14)
-            smem[ly][lx] = map.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+    const int j = blockIdx.x * 16 + threadIdx.x;
+    const int i = blockIdx.y * 16 + threadIdx.y;
 
-        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];
+    const int tid = threadIdx.y * 16 + threadIdx.x;
+    const int lx = tid % 18;
+    const int ly = tid / 18; 
 
-        __syncthreads();
+    if (ly < 14)
+        smem[ly][lx] = map.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
 
-        if (i < rows && j < cols)
-        {
-            int n;
+    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];
 
-            #pragma unroll
-            for (int k = 0; k < 16; ++k)
-            {
-                n = 0;
+    __syncthreads();
 
-                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;
+    if (i < rows && j < cols)
+    {
+        int n;
 
+        #pragma unroll
+        for (int k = 0; k < 16; ++k)
+        {
             n = 0;
 
-            if (e == 2)
+            if (smem[threadIdx.y + 1][threadIdx.x + 1] == 1)
             {
-                n += smem[threadIdx.y    ][threadIdx.x    ] == 1;
-                n += smem[threadIdx.y    ][threadIdx.x + 1] == 1;
-                n += smem[threadIdx.y    ][threadIdx.x + 2] == 1;
+                n += smem[threadIdx.y    ][threadIdx.x    ] == 2;
+                n += smem[threadIdx.y    ][threadIdx.x + 1] == 2;
+                n += smem[threadIdx.y    ][threadIdx.x + 2] == 2;
                 
-                n += smem[threadIdx.y + 1][threadIdx.x    ] == 1;
-                n += smem[threadIdx.y + 1][threadIdx.x + 2] == 1;
+                n += smem[threadIdx.y + 1][threadIdx.x    ] == 2;
+                n += smem[threadIdx.y + 1][threadIdx.x + 2] == 2;
                 
-                n += smem[threadIdx.y + 2][threadIdx.x    ] == 1;
-                n += smem[threadIdx.y + 2][threadIdx.x + 1] == 1;
-                n += smem[threadIdx.y + 2][threadIdx.x + 2] == 1;
+                n += smem[threadIdx.y + 2][threadIdx.x    ] == 2;
+                n += smem[threadIdx.y + 2][threadIdx.x + 1] == 2;
+                n += smem[threadIdx.y + 2][threadIdx.x + 2] == 2;
             }
 
             if (n > 0)
-            {
-                const unsigned int ind = atomicInc(&counter, (unsigned int)(-1));
-                st[ind] = make_ushort2(j + 1, i + 1);
-            }
+                smem[threadIdx.y + 1][threadIdx.x + 1] = 2;
         }
 
-        #endif
-    }
+        const int e = smem[threadIdx.y + 1][threadIdx.x + 1];
 
-    void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+        map.ptr(i + 1)[j + 1] = e;
 
-        edgesHysteresisLocal<<<grid, block>>>(map, st1, rows, cols);
-        cudaSafeCall( cudaGetLastError() );
+        n = 0;
 
-        cudaSafeCall(cudaThreadSynchronize());
+        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);
+        }
     }
 
-    __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};
+    #endif
+}
 
-    __global__ void edgesHysteresisGlobal(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols, int count)
-    {
-        #if __CUDA_ARCH__ >= 120
+void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        const int stack_size = 512;
-        
-        __shared__ unsigned int s_counter;
-        __shared__ unsigned int s_ind;
-        __shared__ ushort2 s_st[stack_size];
+    edgesHysteresisLocal<<<grid, block>>>(map, st1, rows, cols);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (threadIdx.x == 0)
-            s_counter = 0;
-        __syncthreads();
+    cudaSafeCall(cudaThreadSynchronize());
+}
+
+__constant__ int c_dx[8] = {-1,  0,  1, -1, 1, -1, 0, 1};
+__constant__ int c_dy[8] = {-1, -1, -1,  0, 0,  1, 1, 1};
+
+__global__ void edgesHysteresisGlobal(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols, int count)
+{
+    #if __CUDA_ARCH__ >= 120
+
+    const int stack_size = 512;
+    
+    __shared__ unsigned int s_counter;
+    __shared__ unsigned int s_ind;
+    __shared__ ushort2 s_st[stack_size];
+
+    if (threadIdx.x == 0)
+        s_counter = 0;
+    __syncthreads();
 
-        int ind = blockIdx.y * gridDim.x + blockIdx.x;
+    int ind = blockIdx.y * gridDim.x + blockIdx.x;
 
-        if (ind < count)
+    if (ind < count)
+    {
+        ushort2 pos = st1[ind];
+
+        if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
         {
-            ushort2 pos = st1[ind];
+            if (threadIdx.x < 8)
+            {
+                pos.x += c_dx[threadIdx.x];
+                pos.y += c_dy[threadIdx.x];
+
+                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 (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+            while (s_counter > 0 && s_counter <= stack_size - blockDim.x)
             {
-                if (threadIdx.x < 8)
+                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];
-                    pos.y += c_dy[threadIdx.x];
+                    pos.x += c_dx[threadIdx.x & 7];
+                    pos.y += c_dy[threadIdx.x & 7];
 
                     if (map.ptr(pos.y)[pos.x] == 1)
                     {
@@ -388,103 +419,75 @@ namespace cv { namespace gpu { namespace canny
                     }
                 }
                 __syncthreads();
+            }
 
-                while (s_counter > 0 && s_counter <= stack_size - blockDim.x)
+            if (s_counter > 0)
+            {
+                if (threadIdx.x == 0)
                 {
-                    const int subTaskIdx = threadIdx.x >> 3;
-                    const int portion = min(s_counter, blockDim.x >> 3);
-
-                    pos.x = pos.y = 0;
-
-                    if (subTaskIdx < portion)
-                        pos = s_st[s_counter - 1 - subTaskIdx];
-                    __syncthreads();
-                        
-                    if (threadIdx.x == 0)
-                        s_counter -= portion;
-                    __syncthreads();
-                     
-                    if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
-                    {
-                        pos.x += c_dx[threadIdx.x & 7];
-                        pos.y += c_dy[threadIdx.x & 7];
-
-                        if (map.ptr(pos.y)[pos.x] == 1)
-                        {
-                            map.ptr(pos.y)[pos.x] = 2;
-
-                            ind = atomicInc(&s_counter, (unsigned int)(-1));
-
-                            s_st[ind] = pos;
-                        }
-                    }
-                    __syncthreads();
+                    ind = atomicAdd(&counter, s_counter);
+                    s_ind = ind - s_counter;
                 }
+                __syncthreads();
 
-                if (s_counter > 0)
-                {
-                    if (threadIdx.x == 0)
-                    {
-                        ind = atomicAdd(&counter, s_counter);
-                        s_ind = ind - s_counter;
-                    }
-                    __syncthreads();
-
-                    ind = s_ind;
+                ind = s_ind;
 
-                    for (int i = threadIdx.x; i < s_counter; i += blockDim.x)
-                    {
-                        st2[ind + i] = s_st[i];
-                    }
+                for (int i = threadIdx.x; i < s_counter; i += blockDim.x)
+                {
+                    st2[ind + i] = s_st[i];
                 }
             }
         }
-
-        #endif
     }
 
-    void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols)
-    {
-        void* counter_ptr;
-        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, "cv::gpu::canny::counter") );
-        
-        unsigned int count;
-        cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+    #endif
+}
 
-        while (count > 0)
-        {
-            cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
+void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols)
+{
+    void* counter_ptr;
+    cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, counter) );
+    
+    unsigned int count;
+    cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
 
-            dim3 block(128, 1, 1);
-            dim3 grid(min(count, 65535u), divUp(count, 65535), 1);
-            edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, rows, cols, count);
-            cudaSafeCall( cudaGetLastError() );
+    while (count > 0)
+    {
+        cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
 
-            cudaSafeCall(cudaThreadSynchronize());
+        dim3 block(128, 1, 1);
+        dim3 grid(min(count, 65535u), divUp(count, 65535), 1);
+        edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, rows, cols, count);
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+        cudaSafeCall(cudaThreadSynchronize());
 
-            std::swap(st1, st2);
-        }
+        cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+
+        std::swap(st1, st2);
     }
+}
 
-    __global__ void getEdges(PtrStepi map, PtrStepb dst, int rows, int cols)
-    {
-        const int j = blockIdx.x * 16 + threadIdx.x;
-        const int i = blockIdx.y * 16 + threadIdx.y;
+__global__ void getEdges(PtrStepi map, PtrStepb dst, int rows, int cols)
+{
+    const int j = blockIdx.x * 16 + threadIdx.x;
+    const int i = blockIdx.y * 16 + threadIdx.y;
 
-        if (i < rows && j < cols)
-            dst.ptr(i)[j] = (uchar)(-(map.ptr(i + 1)[j + 1] >> 1));
-    }
+    if (i < rows && j < cols)
+        dst.ptr(i)[j] = (uchar)(-(map.ptr(i + 1)[j + 1] >> 1));
+}
 
-    void getEdges_gpu(PtrStepi map, PtrStepb dst, int rows, int cols)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+void getEdges_gpu(PtrStepi map, PtrStepb dst, int rows, int cols)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        getEdges<<<grid, block>>>(map, dst, rows, cols);
-        cudaSafeCall( cudaGetLastError() );
+    getEdges<<<grid, block>>>(map, dst, rows, cols);
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
-}}}
+    cudaSafeCall(cudaThreadSynchronize());
+}
+
+} // namespace canny
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/color.cu b/modules/gpu/src/cuda/color.cu
index dfa74290efae2c38a60a44a8adeedc0eabd6c941..4da3f77c7b40b352a8ce87584e45d2e5ac5274c7 100644
--- a/modules/gpu/src/cuda/color.cu
+++ b/modules/gpu/src/cuda/color.cu
@@ -44,336 +44,337 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/color.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    template <> struct TransformFunctorTraits<bgra_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<bgra_to_bgr555_traits::functor_type> : DefaultTransformFunctorTraits<bgra_to_bgr555_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_bgr555_traits::functor_type> : DefaultTransformFunctorTraits<rgba_to_bgr555_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgra_to_bgr565_traits::functor_type> : DefaultTransformFunctorTraits<bgra_to_bgr565_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_bgr565_traits::functor_type> : DefaultTransformFunctorTraits<rgba_to_bgr565_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<bgr555_to_bgra_traits::functor_type> : DefaultTransformFunctorTraits<bgr555_to_bgra_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgr555_to_rgba_traits::functor_type> : DefaultTransformFunctorTraits<bgr555_to_rgba_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgr565_to_bgra_traits::functor_type> : DefaultTransformFunctorTraits<bgr565_to_bgra_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgr565_to_rgba_traits::functor_type> : DefaultTransformFunctorTraits<bgr565_to_rgba_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<gray_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<gray_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<gray_to_bgr555_traits::functor_type> : DefaultTransformFunctorTraits<gray_to_bgr555_traits::functor_type>
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<gray_to_bgr565_traits::functor_type> : DefaultTransformFunctorTraits<gray_to_bgr565_traits::functor_type>
-    {
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<bgra_to_yuv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_yuv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_yuv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_yuv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<yuv4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<yuv4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<yuv4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<yuv4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<bgra_to_YCrCb4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_YCrCb4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_YCrCb4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_YCrCb4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<YCrCb4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<YCrCb4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<YCrCb4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<YCrCb4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };    
-
-    template <> struct TransformFunctorTraits<bgra_to_xyz4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_xyz4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_xyz4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_xyz4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<xyz4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<xyz4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<xyz4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<xyz4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<bgra_to_hsv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_hsv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_hsv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_hsv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<hsv4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hsv4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<hsv4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hsv4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<bgra_to_hls4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_hls4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_hls4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_hls4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <> struct TransformFunctorTraits<hls4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hls4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<hls4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hls4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, traits) \
-        void name(const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream) \
-        { \
-            traits::functor_type functor = traits::create_functor(); \
-            typedef typename traits::functor_type::argument_type src_t; \
-            typedef typename traits::functor_type::result_type   dst_t; \
-            transform((DevMem2D_<src_t>)src, (DevMem2D_<dst_t>)dst, functor, stream); \
-        }
-
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, name ## _traits)
-
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(name) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
-
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(name) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv4)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgra)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls4)
-
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgra)
-
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_x = 8 };
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr555_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr555_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr565_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr565_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_bgra_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_rgba_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_bgra_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_rgba_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr555_traits::functor_type)
+{
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr565_traits::functor_type)
+{
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_yuv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_yuv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_YCrCb4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_YCrCb4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};    
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_xyz4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_xyz4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hsv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hsv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hls4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hls4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hls4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hls4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, traits) \
+    void name(const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream) \
+    { \
+        traits::functor_type functor = traits::create_functor(); \
+        typedef typename traits::functor_type::argument_type src_t; \
+        typedef typename traits::functor_type::result_type   dst_t; \
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<src_t>)src, (DevMem2D_<dst_t>)dst, functor, stream); \
+    }
+
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, name ## _traits)
+
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(name) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
+
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(name) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv4)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgra)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls4)
+
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgra)
+
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/column_filter.cu b/modules/gpu/src/cuda/column_filter.cu
index 29b828e7ce19ea13e4be3273c5a183d290d5f0d2..c16ca82d812b5601963362d23edcaa99aad998d8 100644
--- a/modules/gpu/src/cuda/column_filter.cu
+++ b/modules/gpu/src/cuda/column_filter.cu
@@ -47,8 +47,7 @@
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
 #define MAX_KERNEL_SIZE 16
 #define BLOCK_DIM_X 16
@@ -56,195 +55,195 @@ using namespace cv::gpu::device;
 #define RESULT_STEPS 8
 #define HALO_STEPS 1
 
-namespace filter_column
+namespace column_filter {
+
+__constant__ float c_kernel[MAX_KERNEL_SIZE];
+
+void loadKernel(const float kernel[], int ksize)
 {
-    __constant__ float c_kernel[MAX_KERNEL_SIZE];
+    cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
+}
 
-    void loadKernel(const float kernel[], int ksize)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
-    }
+template <int KERNEL_SIZE, typename T, typename D, typename B>
+__global__ void linearColumnFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
+{
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
 
-    template <int KERNEL_SIZE, typename T, typename D, typename B>
-    __global__ void linearColumnFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
-    {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+    __shared__ T smem[BLOCK_DIM_X][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_Y + 1];
 
-        __shared__ T smem[BLOCK_DIM_X][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_Y + 1];
+    //Offset to the upper halo edge
+    const int x = blockIdx.x * BLOCK_DIM_X + threadIdx.x;
+    const int y = (blockIdx.y * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_Y + threadIdx.y;
 
-        //Offset to the upper halo edge
-        const int x = blockIdx.x * BLOCK_DIM_X + threadIdx.x;
-        const int y = (blockIdx.y * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_Y + threadIdx.y;
+    if (x < src.cols)
+    {
+        const T* src_col = src.ptr() + x;
 
-        if (x < src.cols)
-        {
-            const T* src_col = src.ptr() + x;
+        //Main data
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
+            smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
 
-            //Main data
-            #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-                smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
+        //Upper halo
+        #pragma unroll
+        for(int i = 0; i < HALO_STEPS; ++i)
+            smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_low(y + i * BLOCK_DIM_Y, src_col, src.step);
 
-            //Upper halo
-            #pragma unroll
-            for(int i = 0; i < HALO_STEPS; ++i)
-                smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_low(y + i * BLOCK_DIM_Y, src_col, src.step);
+        //Lower halo
+        #pragma unroll
+        for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
+            smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y]=  b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
 
-            //Lower halo
-            #pragma unroll
-            for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
-                smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y]=  b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
+        __syncthreads();
 
-            __syncthreads();
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
+        {
+            sum_t sum = VecTraits<sum_t>::all(0);
 
             #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-            {
-                sum_t sum = VecTraits<sum_t>::all(0);
-
-                #pragma unroll
-                for(int j = 0; j < KERNEL_SIZE; ++j)
-                    sum = sum + smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y + j - anchor] * c_kernel[j];
+            for(int j = 0; j < KERNEL_SIZE; ++j)
+                sum = sum + smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y + j - anchor] * c_kernel[j];
 
-                int dstY = y + i * BLOCK_DIM_Y;
+            int dstY = y + i * BLOCK_DIM_Y;
 
-                if (dstY < src.rows)
-                    dst.ptr(dstY)[x] = saturate_cast<D>(sum);
-            }
+            if (dstY < src.rows)
+                dst.ptr(dstY)[x] = saturate_cast<D>(sum);
         }
     }
 }
 
-namespace cv { namespace gpu { namespace filters
-{
-    template <int ksize, typename T, typename D, template<typename> class B>
-    void linearColumnFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
-    {        
-        const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
-        const dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, RESULT_STEPS * BLOCK_DIM_Y));
+template <int ksize, typename T, typename D, template<typename> class B>
+void linearColumnFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
+{        
+    const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
+    const dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, RESULT_STEPS * BLOCK_DIM_Y));
 
-        B<T> b(src.rows);
+    B<T> b(src.rows);
 
-        filter_column::linearColumnFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
-        cudaSafeCall( cudaGetLastError() );
+    linearColumnFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <typename T, typename D>
-    void linearColumnFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
+template <typename T, typename D>
+void linearColumnFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
+    static const caller_t callers[5][17] = 
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
-        static const caller_t callers[5][17] = 
         {
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<2 , T, D, BrdColReflect101>,
-                linearColumnFilter_caller<3 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<4 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<5 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<6 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<7 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<8 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<9 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<10, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<11, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<12, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<13, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<14, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<15, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<16, T, D, BrdColReflect101> 
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<2 , T, D, BrdColReplicate>,
-                linearColumnFilter_caller<3 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<4 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<5 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<6 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<7 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<8 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<9 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<10, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<11, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<12, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<13, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<14, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<15, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<16, T, D, BrdColReplicate>
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<2 , T, D, BrdColConstant>,
-                linearColumnFilter_caller<3 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<4 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<5 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<6 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<7 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<8 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<9 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<10, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<11, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<12, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<13, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<14, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<15, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<16, T, D, BrdColConstant> 
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<2 , T, D, BrdColReflect>,
-                linearColumnFilter_caller<3 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<4 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<5 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<6 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<7 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<8 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<9 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<10, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<11, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<12, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<13, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<14, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<15, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<16, T, D, BrdColReflect>
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<2 , T, D, BrdColWrap>,
-                linearColumnFilter_caller<3 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<4 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<5 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<6 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<7 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<8 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<9 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<10, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<11, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<12, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<13, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<14, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<15, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<16, T, D, BrdColWrap>,
-            }
-        };
-        
-        filter_column::loadKernel(kernel, ksize);
-
-        callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
-    }
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<2 , T, D, BrdColReflect101>,
+            linearColumnFilter_caller<3 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<4 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<5 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<6 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<7 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<8 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<9 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<10, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<11, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<12, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<13, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<14, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<15, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<16, T, D, BrdColReflect101> 
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<2 , T, D, BrdColReplicate>,
+            linearColumnFilter_caller<3 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<4 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<5 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<6 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<7 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<8 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<9 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<10, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<11, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<12, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<13, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<14, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<15, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<16, T, D, BrdColReplicate>
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<2 , T, D, BrdColConstant>,
+            linearColumnFilter_caller<3 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<4 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<5 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<6 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<7 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<8 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<9 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<10, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<11, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<12, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<13, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<14, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<15, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<16, T, D, BrdColConstant> 
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<2 , T, D, BrdColReflect>,
+            linearColumnFilter_caller<3 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<4 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<5 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<6 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<7 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<8 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<9 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<10, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<11, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<12, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<13, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<14, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<15, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<16, T, D, BrdColReflect>
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<2 , T, D, BrdColWrap>,
+            linearColumnFilter_caller<3 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<4 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<5 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<6 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<7 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<8 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<9 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<10, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<11, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<12, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<13, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<14, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<15, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<16, T, D, BrdColWrap>,
+        }
+    };
+    
+    loadKernel(kernel, ksize);
+
+    callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
+}
+
+template void linearColumnFilter_gpu<float , uchar >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float4, uchar4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearColumnFilter_gpu<float , short >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearColumnFilter_gpu<float2, short2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float3, short3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float , int   >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+
+} // namespace column_filter
 
-    template void linearColumnFilter_gpu<float , uchar >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float4, uchar4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearColumnFilter_gpu<float , short >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearColumnFilter_gpu<float2, short2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float3, short3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float , int   >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/copy_make_border.cu b/modules/gpu/src/cuda/copy_make_border.cu
index 89af4e07e98e04d66f2be94e16e9ea4b1e31cd48..5603742302d8e0ad332890c7675c61af4ea59979 100644
--- a/modules/gpu/src/cuda/copy_make_border.cu
+++ b/modules/gpu/src/cuda/copy_make_border.cu
@@ -43,85 +43,87 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace copy_make_border {
+
+template <typename Ptr2D, typename T> __global__ void copyMakeBorder(const Ptr2D src, DevMem2D_<T> dst, int top, int left)
 {
-    template <typename Ptr2D, typename T> __global__ void copyMakeBorder(const Ptr2D src, DevMem2D_<T> dst, int top, int left)
-    {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < dst.cols && y < dst.rows)
+        dst.ptr(y)[x] = src(y - top, x - left);
+}
+
+template <template <typename> class B, typename T> struct CopyMakeBorderDispatcher
+{
+    static void call(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, int top, int left, 
+        const typename VecTraits<T>::elem_type* borderValue, cudaStream_t stream)
+    {        
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+
+        B<T> brd(src.rows, src.cols, VecTraits<T>::make(borderValue));
+        BorderReader< PtrStep<T>, B<T> > brdSrc(src, brd);
 
-        if (x < dst.cols && y < dst.rows)
-            dst.ptr(y)[x] = src(y - top, x - left);
+        copyMakeBorder<<<grid, block, 0, stream>>>(brdSrc, dst, top, left);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
     }
+};
 
-    template <template <typename> class B, typename T> struct CopyMakeBorderDispatcher
+template <typename T, int cn> void copyMakeBorder_gpu(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, 
+    const T* borderValue, cudaStream_t stream)
+{
+    typedef typename TypeVec<T, cn>::vec_type vec_type;
+
+    typedef void (*caller_t)(const DevMem2D_<vec_type>& src, const DevMem2D_<vec_type>& dst, int top, int left, const T* borderValue, cudaStream_t stream);
+
+    static const caller_t callers[5] = 
     {
-        static void call(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, int top, int left, 
-            const typename VecTraits<T>::elem_type* borderValue, cudaStream_t stream)
-        {        
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        CopyMakeBorderDispatcher<BrdReflect101, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdReplicate, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdConstant, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdReflect, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdWrap, vec_type>::call 
+    };
 
-            B<T> brd(src.rows, src.cols, VecTraits<T>::make(borderValue));
-            BorderReader< PtrStep<T>, B<T> > brdSrc(src, brd);
+    callers[borderMode](DevMem2D_<vec_type>(src), DevMem2D_<vec_type>(dst), top, left, borderValue, stream);
+}
 
-            copyMakeBorder<<<grid, block, 0, stream>>>(brdSrc, dst, top, left);
-            cudaSafeCall( cudaGetLastError() );
+template void copyMakeBorder_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
 
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+//template void copyMakeBorder_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
 
-    template <typename T, int cn> void copyMakeBorder_gpu(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, 
-        const T* borderValue, cudaStream_t stream)
-    {
-        typedef typename TypeVec<T, cn>::vec_type vec_type;
+template void copyMakeBorder_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
 
-        typedef void (*caller_t)(const DevMem2D_<vec_type>& src, const DevMem2D_<vec_type>& dst, int top, int left, const T* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
 
-        static const caller_t callers[5] = 
-        {
-            CopyMakeBorderDispatcher<BrdReflect101, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdReplicate, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdConstant, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdReflect, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdWrap, vec_type>::call 
-        };
+//template void copyMakeBorder_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
 
-        callers[borderMode](DevMem2D_<vec_type>(src), DevMem2D_<vec_type>(dst), top, left, borderValue, stream);
-    }
+template void copyMakeBorder_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+
+} // namespace copy_make_border
 
-    template void copyMakeBorder_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    
-    //template void copyMakeBorder_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    
-    template void copyMakeBorder_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    
-    template void copyMakeBorder_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    
-    //template void copyMakeBorder_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    
-    template void copyMakeBorder_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/element_operations.cu b/modules/gpu/src/cuda/element_operations.cu
index cd724682feccf5643b5014a35f3cf8f348ba0873..7920cc8917c7d03e4b572bb58b112814007ff360 100644
--- a/modules/gpu/src/cuda/element_operations.cu
+++ b/modules/gpu/src/cuda/element_operations.cu
@@ -40,2040 +40,2041 @@
 //
 //M*/
 
+#include "internal_shared.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"
-#include "internal_shared.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    //////////////////////////////////////////////////////////////////////////
-    // add
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T, typename D> struct Add : binary_function<T, T, D>
-    {
-        __device__ __forceinline__ D operator ()(T a, T b) const
-        {
-            return saturate_cast<D>(a + b);
-        }
-    };
+//////////////////////////////////////////////////////////////////////////
+// add
 
-    template <> struct TransformFunctorTraits< Add<ushort, ushort> > : DefaultTransformFunctorTraits< Add<ushort, ushort> >
-    {
-        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 };
-    };
-
-    template <typename T, typename D> void add_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+template <typename T, typename D> struct Add : binary_function<T, T, D>
+{
+    __device__ __forceinline__ D operator ()(T a, T b) const
     {
-        if (mask.data)
-            transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, mask, Add<T, D>(), stream);
-        else
-            transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, Add<T, D>(), stream);
+        return saturate_cast<D>(a + b);
     }
+};
 
-    template void add_gpu<uchar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<uchar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<schar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<ushort, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<short, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<int, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<float, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<double, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    template <typename T, typename D> struct AddScalar : unary_function<T, D>
-    {
-        AddScalar(double 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>  >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddScalar<short, short> > : DefaultTransformFunctorTraits< AddScalar<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddScalar<int, int> > : DefaultTransformFunctorTraits< AddScalar<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddScalar<float, float> > : DefaultTransformFunctorTraits< AddScalar<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+template <> struct TransformFunctorTraits< Add<ushort, ushort> > : DefaultTransformFunctorTraits< Add<ushort, ushort> >
+{
+    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 };
+};
 
-    template <typename T, typename D> void add_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+template <typename T, typename D> void add_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+{
+    if (mask.data)
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, mask, Add<T, D>(), stream);
+    else
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, Add<T, D>(), stream);
+}
+
+template void add_gpu<uchar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<uchar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<schar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<ushort, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<ushort, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<ushort, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<short, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<short, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<int, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<int, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<int, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<int, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<int, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<float, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<float, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<double, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+template <typename T, typename D> struct AddScalar : unary_function<T, D>
+{
+    AddScalar(double val_) : val(val_) {}
+    __device__ __forceinline__ D operator ()(T a) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        AddScalar<T, D> op(val);
-        if (mask.data)
-            transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, mask, op, stream);
-        else
-            transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+        return saturate_cast<D>(a + val);
     }
+    const double val;
+};
 
-    template void add_gpu<uchar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<uchar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<schar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<ushort, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<short, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<int, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<float, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<double, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //////////////////////////////////////////////////////////////////////////
-    // subtract
-
-    template <typename T, typename D> struct Subtract : binary_function<T, T, D>
-    {
-        __device__ __forceinline__ D operator ()(T a, T b) const
-        {
-            return saturate_cast<D>(a - b);
-        }
-    };
-
-    template <> struct TransformFunctorTraits< Subtract<ushort, ushort> > : DefaultTransformFunctorTraits< Subtract<ushort, ushort> >
-    {
-        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 };
-    };
+template <> struct TransformFunctorTraits< AddScalar<ushort, ushort> > : DefaultTransformFunctorTraits< AddScalar<ushort, ushort>  >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AddScalar<short, short> > : DefaultTransformFunctorTraits< AddScalar<short, short> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AddScalar<int, int> > : DefaultTransformFunctorTraits< AddScalar<int, int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AddScalar<float, float> > : DefaultTransformFunctorTraits< AddScalar<float, float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <typename T, typename D> void subtract_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+template <typename T, typename D> void add_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&val) );
+    AddScalar<T, D> op(val);
+    if (mask.data)
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, mask, op, stream);
+    else
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void add_gpu<uchar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<uchar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<schar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<ushort, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<ushort, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<ushort, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<short, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<short, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<int, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<int, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<int, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<int, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<int, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<float, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<float, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<float, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void add_gpu<double, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void add_gpu<double, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void add_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//////////////////////////////////////////////////////////////////////////
+// subtract
+
+template <typename T, typename D> struct Subtract : binary_function<T, T, D>
+{
+    __device__ __forceinline__ D operator ()(T a, T b) const
     {
-        if (mask.data)
-            transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, mask, Subtract<T, D>(), stream);
-        else
-            transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, Subtract<T, D>(), stream);
+        return saturate_cast<D>(a - b);
     }
+};
 
-    template void subtract_gpu<uchar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<uchar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<schar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<ushort, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<short, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<int, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<float, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<double, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    template <typename T, typename D> struct SubtractScalar : unary_function<T, D>
-    {
-        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 <> struct TransformFunctorTraits< Subtract<ushort, ushort> > : DefaultTransformFunctorTraits< Subtract<ushort, ushort> >
+{
+    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 };
+};
 
-    template <typename T, typename D> void subtract_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+template <typename T, typename D> void subtract_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+{
+    if (mask.data)
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, mask, Subtract<T, D>(), stream);
+    else
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, Subtract<T, D>(), stream);
+}
+
+template void subtract_gpu<uchar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<uchar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<schar, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<ushort, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<ushort, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<ushort, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<short, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<short, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<int, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<int, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<int, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<int, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<int, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<float, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<float, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<double, uchar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, schar>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, short>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, int>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, float>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+template <typename T, typename D> struct SubtractScalar : unary_function<T, D>
+{
+    SubtractScalar(double val_) : val(val_) {}
+    __device__ __forceinline__ D operator ()(T a) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        SubtractScalar<T, D> op(val);
-        if (mask.data)
-            transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, mask, op, stream);
-        else
-            transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+        return saturate_cast<D>(a - val);
     }
+    const double val;
+};
 
-    template void subtract_gpu<uchar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<uchar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<schar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<ushort, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<short, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<int, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<float, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<double, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //////////////////////////////////////////////////////////////////////////
-    // multiply
-
-    struct multiply_8uc4_32f : binary_function<uint, float, uint>
-    {
-        __device__ __forceinline__ uint operator ()(uint a, float b) const
-        {
-            uint res = 0;
-
-            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;
-        }
-    };
-
-    template <> struct TransformFunctorTraits<multiply_8uc4_32f> : DefaultTransformFunctorTraits<multiply_8uc4_32f>
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
-    };
-
-    void multiply_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream)
-    {
-        transform(static_cast< DevMem2D_<uint> >(src1), src2, static_cast< DevMem2D_<uint> >(dst), multiply_8uc4_32f(), stream);
-    }
+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 };
+};
 
-    struct multiply_16sc4_32f : binary_function<short4, float, short4>
+template <typename T, typename D> void subtract_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&val) );
+    SubtractScalar<T, D> op(val);
+    if (mask.data)
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, mask, op, stream);
+    else
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void subtract_gpu<uchar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<uchar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<schar, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<ushort, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<ushort, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<ushort, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<short, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<short, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<int, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<int, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<int, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<int, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<int, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<float, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<float, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<float, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//template void subtract_gpu<double, uchar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, schar>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, short>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, int>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+//template void subtract_gpu<double, float>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+template void subtract_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+//////////////////////////////////////////////////////////////////////////
+// multiply
+
+struct multiply_8uc4_32f : binary_function<uint, float, uint>
+{
+    __device__ __forceinline__ uint operator ()(uint a, float b) const
     {
-        __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));
-        }
-    };
+        uint res = 0;
 
-    template <> struct TransformFunctorTraits<multiply_16sc4_32f> : DefaultTransformFunctorTraits<multiply_16sc4_32f>
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
-    };
+        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);
 
-    void multiply_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream)
-    {
-        transform(static_cast< DevMem2D_<short4> >(src1), src2, 
-                  static_cast< DevMem2D_<short4> >(dst), multiply_16sc4_32f(), stream);
+        return res;
     }
+};
 
-    template <typename T, typename D> struct Multiply : binary_function<T, T, D>
-    {
-        Multiply(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ D operator ()(T a, T b) const
-        {
-            return saturate_cast<D>(scale * a * b);
-        }
-        const double scale;
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(multiply_8uc4_32f)
+{
+    enum { smart_block_dim_x = 8 };
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 8 };
+};
 
-    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 };
-    };
+void multiply_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream)
+{
+    transform(static_cast< DevMem2D_<uint> >(src1), src2, static_cast< DevMem2D_<uint> >(dst), multiply_8uc4_32f(), stream);
+}
 
-    template <typename T, typename D> void multiply_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream)
+struct multiply_16sc4_32f : binary_function<short4, float, short4>
+{
+    __device__ __forceinline__ short4 operator ()(short4 a, float b) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        Multiply<T, D> op(scale);
-        transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, op, stream);
+        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));
     }
+};
 
-    template void multiply_gpu<uchar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<uchar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<schar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<ushort, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<short, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<int, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<float, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<double, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& 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;
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(multiply_16sc4_32f)
+{
+    enum { smart_block_dim_x = 8 };
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 8 };
+};
 
-    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 };
-    };
+void multiply_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream)
+{
+    transform(static_cast< DevMem2D_<short4> >(src1), src2, 
+              static_cast< DevMem2D_<short4> >(dst), multiply_16sc4_32f(), stream);
+}
 
-    template <typename T, typename D> void multiply_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream)
+template <typename T, typename D> struct Multiply : binary_function<T, T, D>
+{
+    Multiply(double scale_) : scale(scale_) {}
+    __device__ __forceinline__ D operator ()(T a, T b) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        MultiplyScalar<T, D> op(val, scale);
-        transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+        return saturate_cast<D>(scale * a * b);
     }
+    const double scale;
+};
 
-    template void multiply_gpu<uchar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<uchar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<schar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<ushort, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<short, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<int, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<float, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<double, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& 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);
-        }
-    };
-
-    template <> struct TransformFunctorTraits<divide_8uc4_32f> : DefaultTransformFunctorTraits<divide_8uc4_32f>
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
-    };
+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 };
+};
 
-    void divide_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream)
+template <typename T, typename D> void multiply_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&scale) );
+    Multiply<T, D> op(scale);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void multiply_gpu<uchar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<uchar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<schar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<ushort, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<ushort, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<ushort, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<short, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<short, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<int, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<int, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<int, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<int, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<int, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<float, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<float, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<double, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& 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
     {
-        transform(static_cast< DevMem2D_<uchar4> >(src1), src2, static_cast< DevMem2D_<uchar4> >(dst), divide_8uc4_32f(), stream);
+        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 };
+};
 
-    struct divide_16sc4_32f : binary_function<short4, float, short4>
-    {
-        __device__ __forceinline__ short4 operator ()(short4 a, float b) const
-        {
-            return b != 0 ? make_short4(saturate_cast<short>(a.x / b), saturate_cast<uchar>(a.y / b),
-                                        saturate_cast<short>(a.z / b), saturate_cast<uchar>(a.w / b))
-                          : make_short4(0,0,0,0);
-        }
-    };
-
-    template <> struct TransformFunctorTraits<divide_16sc4_32f> : DefaultTransformFunctorTraits<divide_16sc4_32f>
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
-    };
-
-    void divide_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream)
+template <typename T, typename D> void multiply_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&val) );
+    cudaSafeCall( cudaSetDoubleForDevice(&scale) );
+    MultiplyScalar<T, D> op(val, scale);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void multiply_gpu<uchar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<uchar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<schar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<ushort, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<ushort, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<ushort, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<short, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<short, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<int, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<int, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<int, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<int, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<int, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<float, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<float, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<float, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void multiply_gpu<double, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void multiply_gpu<double, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void multiply_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& 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
     {
-        transform(static_cast< DevMem2D_<short4> >(src1), src2, static_cast< DevMem2D_<short4> >(dst), divide_16sc4_32f(), stream);
+        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);
     }
+};
 
-    template <typename T, typename D> struct Divide : binary_function<T, T, D>
-    {
-        Divide(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ D operator ()(T a, T b) const
-        {
-            return b != 0 ? saturate_cast<D>(scale * a / b) : 0;
-        }
-        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 DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream)
-    {
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        Divide<T, D> op(scale);
-        transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, op, stream);
-    }
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(divide_8uc4_32f)
+{
+    enum { smart_block_dim_x = 8 };
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 8 };
+};
 
-    template void divide_gpu<uchar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<uchar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<schar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<ushort, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<short, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<int, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<float, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<double, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    
-    template <typename T, typename D> struct DivideScalar : unary_function<T, D>
-    {
-        DivideScalar(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;
-    };
+void divide_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream)
+{
+    transform(static_cast< DevMem2D_<uchar4> >(src1), src2, static_cast< DevMem2D_<uchar4> >(dst), divide_8uc4_32f(), stream);
+}
 
-    template <> struct TransformFunctorTraits< DivideScalar<ushort, ushort> > : DefaultTransformFunctorTraits< DivideScalar<ushort, ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivideScalar<short, short> > : DefaultTransformFunctorTraits< DivideScalar<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivideScalar<int, int> > : DefaultTransformFunctorTraits< DivideScalar<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivideScalar<float, float> > : DefaultTransformFunctorTraits< DivideScalar<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
 
-    template <typename T, typename D> void divide_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream)
+struct divide_16sc4_32f : binary_function<short4, float, short4>
+{
+    __device__ __forceinline__ short4 operator ()(short4 a, float b) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        DivideScalar<T, D> op(val, scale);
-        transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+        return b != 0 ? make_short4(saturate_cast<short>(a.x / b), saturate_cast<uchar>(a.y / b),
+                                    saturate_cast<short>(a.z / b), saturate_cast<uchar>(a.w / b))
+                      : make_short4(0,0,0,0);
     }
+};
 
-    template void divide_gpu<uchar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<uchar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<schar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<ushort, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<short, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<int, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<float, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    //template void divide_gpu<double, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-
-    template <typename T, typename D> struct Reciprocal : unary_function<T, D>
-    {
-        Reciprocal(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ D operator ()(T a) const
-        {
-            return a != 0 ? saturate_cast<D>(scale / a) : 0;
-        }
-        const double scale;
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(divide_16sc4_32f)
+{
+    enum { smart_block_dim_x = 8 };
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 8 };
+};
 
-    template <> struct TransformFunctorTraits< Reciprocal<ushort, ushort> > : DefaultTransformFunctorTraits< Reciprocal<ushort, ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Reciprocal<short, short> > : DefaultTransformFunctorTraits< Reciprocal<short, short> >
-    {
-        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 };
-    };
+void divide_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream)
+{
+    transform(static_cast< DevMem2D_<short4> >(src1), src2, static_cast< DevMem2D_<short4> >(dst), divide_16sc4_32f(), stream);
+}
 
-    template <typename T, typename D> void divide_gpu(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+template <typename T, typename D> struct Divide : binary_function<T, T, D>
+{
+    Divide(double scale_) : scale(scale_) {}
+    __device__ __forceinline__ D operator ()(T a, T b) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&scalar) );
-        Reciprocal<T, D> op(scalar);
-        transform((DevMem2D_<T>)src2, (DevMem2D_<D>)dst, op, stream);
+        return b != 0 ? saturate_cast<D>(scale * a / b) : 0;
     }
+    const double scale;
+};
 
-    template void divide_gpu<uchar, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<uchar, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //template void divide_gpu<schar, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //template void divide_gpu<ushort, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<ushort, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<ushort, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //template void divide_gpu<short, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<short, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<short, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<short, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<short, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<short, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<short, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //template void divide_gpu<int, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<int, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<int, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<int, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<int, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<int, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<int, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //template void divide_gpu<float, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<float, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<float, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<float, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<float, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<float, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<float, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //template void divide_gpu<double, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<double, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<double, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<double, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<double, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void divide_gpu<double, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void divide_gpu<double, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //////////////////////////////////////////////////////////////////////////
-    // absdiff
-
-    template <typename T> struct Absdiff : 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));
-        }
-    };
-
-    template <> struct TransformFunctorTraits< Absdiff<ushort> > : DefaultTransformFunctorTraits< Absdiff<ushort> >
-    {
-        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 };
-    };
+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> void absdiff_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+template <typename T, typename D> void divide_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&scale) );
+    Divide<T, D> op(scale);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void divide_gpu<uchar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<uchar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<schar, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<ushort, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<ushort, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<ushort, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<short, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<short, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<short, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<int, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<int, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<int, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<int, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<int, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<int, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<int, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<float, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<float, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<float, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<double, uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<double, double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+template <typename T, typename D> struct DivideScalar : unary_function<T, D>
+{
+    DivideScalar(double val_, double scale_) : val(val_), scale(scale_) {}
+    __device__ __forceinline__ D operator ()(T a) const
     {
-        transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<T>)dst, Absdiff<T>(), stream);
+        return saturate_cast<D>(scale * a / val);
     }
+    const double val;
+    const double scale;
+};
 
-    //template void absdiff_gpu<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void absdiff_gpu<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    //template void absdiff_gpu<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    template <typename T> struct AbsdiffScalar : unary_function<T, T>
-    {
-        AbsdiffScalar(double val_) : val(val_) {}
-        __device__ __forceinline__ T operator ()(T a) const
-        {
-            return saturate_cast<T>(::fabs(a - val));
-        }
-        double val;
-    };
-
-    template <> struct TransformFunctorTraits< AbsdiffScalar<ushort> > : DefaultTransformFunctorTraits< AbsdiffScalar<ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsdiffScalar<short> > : DefaultTransformFunctorTraits< AbsdiffScalar<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsdiffScalar<int> > : DefaultTransformFunctorTraits< AbsdiffScalar<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsdiffScalar<float> > : DefaultTransformFunctorTraits< AbsdiffScalar<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+template <> struct TransformFunctorTraits< DivideScalar<ushort, ushort> > : DefaultTransformFunctorTraits< DivideScalar<ushort, ushort> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< DivideScalar<short, short> > : DefaultTransformFunctorTraits< DivideScalar<short, short> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< DivideScalar<int, int> > : DefaultTransformFunctorTraits< DivideScalar<int, int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< DivideScalar<float, float> > : DefaultTransformFunctorTraits< DivideScalar<float, float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <typename T> void absdiff_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, cudaStream_t stream)
+template <typename T, typename D> void divide_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&val) );
+    cudaSafeCall( cudaSetDoubleForDevice(&scale) );
+    DivideScalar<T, D> op(val, scale);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void divide_gpu<uchar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<uchar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<uchar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<schar, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<schar, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<ushort, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<ushort, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<ushort, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<ushort, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<short, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<short, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<short, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<short, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<int, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<int, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<int, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<int, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<int, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<int, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<int, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<float, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<float, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<float, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<float, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+//template void divide_gpu<double, uchar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, schar >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, ushort>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, short >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, int   >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+//template void divide_gpu<double, float >(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template void divide_gpu<double, double>(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+template <typename T, typename D> struct Reciprocal : unary_function<T, D>
+{
+    Reciprocal(double scale_) : scale(scale_) {}
+    __device__ __forceinline__ D operator ()(T a) const
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        AbsdiffScalar<T> op(val);
-        transform((DevMem2D_<T>)src1, (DevMem2D_<T>)dst, op, stream);
+        return a != 0 ? saturate_cast<D>(scale / a) : 0;
     }
+    const double scale;
+};
 
-    template void absdiff_gpu<uchar >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<schar >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<ushort>(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);                  
-    template void absdiff_gpu<short >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void absdiff_gpu<int   >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);                  
-    //template void absdiff_gpu<float >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);                  
-    template void absdiff_gpu<double>(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
-
-    //////////////////////////////////////////////////////////////////////////////////////
-    // Compare
-
-    template <typename T> struct Equal : binary_function<T, T, uchar>
-    {
-        __device__ __forceinline__ uchar operator()(T src1, T src2) const
-        {
-            return static_cast<uchar>((src1 == src2) * 255);
-        }
-    };
-    template <typename T> struct NotEqual : binary_function<T, T, uchar>
-    {
-        __device__ __forceinline__ uchar operator()(T src1, T src2) const
-        {
-            return static_cast<uchar>((src1 != src2) * 255);
-        }
-    };
-    template <typename T> struct Less : binary_function<T, T, uchar>
-    {
-        __device__ __forceinline__ uchar operator()(T src1, T src2) const
-        {
-            return static_cast<uchar>((src1 < src2) * 255);
-        }
-    };
-    template <typename T> struct LessEqual : binary_function<T, T, uchar>
-    {
-        __device__ __forceinline__ uchar operator()(T src1, T src2) const
-        {
-            return static_cast<uchar>((src1 <= src2) * 255);
-        }
-    };
-
-    template <> struct TransformFunctorTraits< Equal<int> > : DefaultTransformFunctorTraits< Equal<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Equal<float> > : DefaultTransformFunctorTraits< Equal<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< NotEqual<int> > : DefaultTransformFunctorTraits< NotEqual<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< NotEqual<float> > : DefaultTransformFunctorTraits< NotEqual<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Less<int> > : DefaultTransformFunctorTraits< Less<int> >
+template <> struct TransformFunctorTraits< Reciprocal<ushort, ushort> > : DefaultTransformFunctorTraits< Reciprocal<ushort, ushort> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< Reciprocal<short, short> > : DefaultTransformFunctorTraits< Reciprocal<short, short> >
+{
+    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 };
+};
+
+template <typename T, typename D> void divide_gpu(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&scalar) );
+    Reciprocal<T, D> op(scalar);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src2, (DevMem2D_<D>)dst, op, stream);
+}
+
+template void divide_gpu<uchar, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<uchar, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<uchar, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<uchar, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<uchar, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<uchar, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<uchar, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//template void divide_gpu<schar, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<schar, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<schar, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<schar, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<schar, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<schar, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<schar, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//template void divide_gpu<ushort, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<ushort, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<ushort, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<ushort, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<ushort, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<ushort, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<ushort, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//template void divide_gpu<short, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<short, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<short, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<short, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<short, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<short, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<short, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//template void divide_gpu<int, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<int, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<int, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<int, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<int, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<int, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<int, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//template void divide_gpu<float, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<float, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<float, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<float, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<float, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<float, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<float, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//template void divide_gpu<double, uchar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<double, schar >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<double, ushort>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<double, short >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<double, int   >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void divide_gpu<double, float >(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void divide_gpu<double, double>(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//////////////////////////////////////////////////////////////////////////
+// absdiff
+
+template <typename T> struct Absdiff : binary_function<T, T, T>
+{
+    static __device__ __forceinline__ int abs(int a)
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Less<float> > : DefaultTransformFunctorTraits< Less<float> >
+        return ::abs(a);
+    }
+    static __device__ __forceinline__ float abs(float a)
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< LessEqual<int> > : DefaultTransformFunctorTraits< LessEqual<int> >
+        return ::fabsf(a);
+    }
+    static __device__ __forceinline__ double abs(double a)
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< LessEqual<float> > : DefaultTransformFunctorTraits< LessEqual<float> >
+        return ::fabs(a);
+    }
+
+    __device__ __forceinline__ T operator ()(T a, T b) const
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+        return saturate_cast<T>(::abs(a - b));
+    }
+};
+
+template <> struct TransformFunctorTraits< Absdiff<ushort> > : DefaultTransformFunctorTraits< Absdiff<ushort> >
+{
+    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 };
+};
 
-    template <template <typename> class Op, typename T> void compare(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+template <typename T> void absdiff_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<T>)dst, Absdiff<T>(), stream);
+}
+
+//template void absdiff_gpu<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void absdiff_gpu<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+//template void absdiff_gpu<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+template <typename T> struct AbsdiffScalar : unary_function<T, T>
+{
+    AbsdiffScalar(double val_) : val(val_) {}
+    __device__ __forceinline__ T operator ()(T a) const
     {
-        Op<T> op;
-        transform(static_cast< DevMem2D_<T> >(src1), static_cast< DevMem2D_<T> >(src2), dst, op, stream);
+        return saturate_cast<T>(::fabs(a - val));
     }
+    double val;
+};
+
+template <> struct TransformFunctorTraits< AbsdiffScalar<ushort> > : DefaultTransformFunctorTraits< AbsdiffScalar<ushort> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AbsdiffScalar<short> > : DefaultTransformFunctorTraits< AbsdiffScalar<short> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AbsdiffScalar<int> > : DefaultTransformFunctorTraits< AbsdiffScalar<int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AbsdiffScalar<float> > : DefaultTransformFunctorTraits< AbsdiffScalar<float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <typename T> void compare_eq(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+template <typename T> void absdiff_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&val) );
+    AbsdiffScalar<T> op(val);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src1, (DevMem2D_<T>)dst, op, stream);
+}
+
+template void absdiff_gpu<uchar >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<schar >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<ushort>(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);                  
+template void absdiff_gpu<short >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
+template void absdiff_gpu<int   >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);                  
+//template void absdiff_gpu<float >(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);                  
+template void absdiff_gpu<double>(const DevMem2Db& src1, double src2, const DevMem2Db& dst, cudaStream_t stream);
+
+//////////////////////////////////////////////////////////////////////////////////////
+// Compare
+
+template <typename T> struct Equal : binary_function<T, T, uchar>
+{
+    __device__ __forceinline__ uchar operator()(T src1, T src2) const
     {
-        compare<Equal, T>(src1, src2, dst, stream);
+        return static_cast<uchar>((src1 == src2) * 255);
     }
-    template <typename T> void compare_ne(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+};
+template <typename T> struct NotEqual : binary_function<T, T, uchar>
+{
+    __device__ __forceinline__ uchar operator()(T src1, T src2) const
     {
-        compare<NotEqual, T>(src1, src2, dst, stream);
+        return static_cast<uchar>((src1 != src2) * 255);
     }
-    template <typename T> void compare_lt(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+};
+template <typename T> struct Less : binary_function<T, T, uchar>
+{
+    __device__ __forceinline__ uchar operator()(T src1, T src2) const
     {
-        compare<Less, T>(src1, src2, dst, stream);
+        return static_cast<uchar>((src1 < src2) * 255);
     }
-    template <typename T> void compare_le(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+};
+template <typename T> struct LessEqual : binary_function<T, T, uchar>
+{
+    __device__ __forceinline__ uchar operator()(T src1, T src2) const
     {
-        compare<LessEqual, T>(src1, src2, dst, stream);
+        return static_cast<uchar>((src1 <= src2) * 255);
     }
-    
-    template void compare_eq<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_eq<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_eq<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_eq<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_eq<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_eq<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_eq<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    
-    template void compare_ne<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_ne<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_ne<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_ne<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_ne<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_ne<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_ne<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    
-    template void compare_lt<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_lt<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_lt<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_lt<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_lt<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_lt<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_lt<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    
-    template void compare_le<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_le<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_le<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_le<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_le<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_le<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void compare_le<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-
-
-    //////////////////////////////////////////////////////////////////////////
-    // Unary bitwise logical matrix operations
-
-    enum { UN_OP_NOT };
-
-    template <typename T, int opid>
-    struct UnOp;
-
-    template <typename T>
-    struct UnOp<T, UN_OP_NOT>
-    { 
-        static __device__ __forceinline__ T call(T v) { return ~v; }
-    };
+};
 
+template <> struct TransformFunctorTraits< Equal<int> > : DefaultTransformFunctorTraits< Equal<int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< Equal<float> > : DefaultTransformFunctorTraits< Equal<float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< NotEqual<int> > : DefaultTransformFunctorTraits< NotEqual<int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< NotEqual<float> > : DefaultTransformFunctorTraits< NotEqual<float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< Less<int> > : DefaultTransformFunctorTraits< Less<int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< Less<float> > : DefaultTransformFunctorTraits< Less<float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< LessEqual<int> > : DefaultTransformFunctorTraits< LessEqual<int> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< LessEqual<float> > : DefaultTransformFunctorTraits< LessEqual<float> >
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <int opid>
-    __global__ void bitwiseUnOpKernel(int rows, int width, const PtrStepb src, PtrStepb dst)
-    {
-        const int x = (blockDim.x * blockIdx.x + threadIdx.x) * 4;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+template <template <typename> class Op, typename T> void compare(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    Op<T> op;
+    OPENCV_DEVICE_NAMESPACE_ transform(static_cast< DevMem2D_<T> >(src1), static_cast< DevMem2D_<T> >(src2), dst, op, stream);
+}
 
-        if (y < rows) 
+template <typename T> void compare_eq(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    compare<Equal, T>(src1, src2, dst, stream);
+}
+template <typename T> void compare_ne(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    compare<NotEqual, T>(src1, src2, dst, stream);
+}
+template <typename T> void compare_lt(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    compare<Less, T>(src1, src2, dst, stream);
+}
+template <typename T> void compare_le(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream)
+{
+    compare<LessEqual, T>(src1, src2, dst, stream);
+}
+
+template void compare_eq<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_eq<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_eq<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_eq<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_eq<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_eq<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_eq<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+template void compare_ne<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_ne<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_ne<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_ne<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_ne<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_ne<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_ne<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+template void compare_lt<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_lt<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_lt<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_lt<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_lt<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_lt<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_lt<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+template void compare_le<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_le<schar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_le<ushort>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_le<short >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_le<int   >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_le<float >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void compare_le<double>(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+
+//////////////////////////////////////////////////////////////////////////
+// Unary bitwise logical matrix operations
+
+enum { UN_OP_NOT };
+
+template <typename T, int opid>
+struct UnOp;
+
+template <typename T>
+struct UnOp<T, UN_OP_NOT>
+{ 
+    static __device__ __forceinline__ T call(T v) { return ~v; }
+};
+
+
+template <int opid>
+__global__ void bitwiseUnOpKernel(int rows, int width, const PtrStepb src, PtrStepb dst)
+{
+    const int x = (blockDim.x * blockIdx.x + threadIdx.x) * 4;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (y < rows) 
+    {
+        uchar* dst_ptr = dst.ptr(y) + x;
+        const uchar* src_ptr = src.ptr(y) + x;
+        if (x + sizeof(uint) - 1 < width)
         {
-            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
+            *(uint*)dst_ptr = UnOp<uint, opid>::call(*(uint*)src_ptr);
+        }
+        else
+        {
+            const uchar* src_end = src.ptr(y) + width;
+            while (src_ptr < src_end)
             {
-                const uchar* src_end = src.ptr(y) + width;
-                while (src_ptr < src_end)
-                {
-                    *dst_ptr++ = UnOp<uchar, opid>::call(*src_ptr++);
-                }
+                *dst_ptr++ = UnOp<uchar, opid>::call(*src_ptr++);
             }
         }
     }
+}
 
 
-    template <int opid>
-    void bitwiseUnOp(int rows, int width, const PtrStepb src, PtrStepb dst, 
-                     cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(width, threads.x * sizeof(uint)), 
-                  divUp(rows, threads.y));
+template <int opid>
+void bitwiseUnOp(int rows, int width, const PtrStepb src, PtrStepb dst, 
+                 cudaStream_t stream)
+{
+    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() );
+    bitwiseUnOpKernel<opid><<<grid, threads>>>(rows, width, src, dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0) 
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    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;
+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]) 
-        {
-            T* dst_row = (T*)dst.ptr(y);
-            const T* src_row = (const T*)src.ptr(y);
+    if (x < cols && y < rows && mask.ptr(y)[x / cn]) 
+    {
+        T* dst_row = (T*)dst.ptr(y);
+        const T* src_row = (const T*)src.ptr(y);
 
-            dst_row[x] = UnOp<T, opid>::call(src_row[x]);
-        }
+        dst_row[x] = UnOp<T, opid>::call(src_row[x]);
     }
+}
 
 
-    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));
+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() );
+    bitwiseUnOpKernel<T, opid><<<grid, threads>>>(rows, cols, cn, src, mask, dst); 
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0) 
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    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);
-    }
+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 <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);
+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
+//////////////////////////////////////////////////////////////////////////
+// Binary bitwise logical matrix operations
 
-    enum { BIN_OP_OR, BIN_OP_AND, BIN_OP_XOR };
+enum { BIN_OP_OR, BIN_OP_AND, BIN_OP_XOR };
 
-    template <typename T, int opid>
-    struct BinOp;
+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; } 
-    };
+template <typename T>
+struct BinOp<T, BIN_OP_OR>
+{ 
+    static __device__ __forceinline__ T call(T a, T b) { return a | b; } 
+};
 
 
-    template <typename T>
-    struct BinOp<T, BIN_OP_AND>
-    { 
-        static __device__ __forceinline__ T call(T a, T b) { return a & b; } 
-    };
+template <typename T>
+struct BinOp<T, BIN_OP_AND>
+{ 
+    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 <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)
+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) 
     {
-        const int x = (blockDim.x * blockIdx.x + threadIdx.x) * 4;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        uchar* dst_ptr = dst.ptr(y) + x;
+        const uchar* src1_ptr = src1.ptr(y) + x;
+        const uchar* src2_ptr = src2.ptr(y) + x;
 
-        if (y < rows) 
+        if (x + sizeof(uint) - 1 < width)
         {
-            uchar* dst_ptr = dst.ptr(y) + x;
-            const uchar* src1_ptr = src1.ptr(y) + x;
-            const uchar* src2_ptr = src2.ptr(y) + x;
-
-            if (x + sizeof(uint) - 1 < width)
-            {
-                *(uint*)dst_ptr = BinOp<uint, opid>::call(*(uint*)src1_ptr, *(uint*)src2_ptr);
-            }
-            else
+            *(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)
             {
-                const uchar* src1_end = src1.ptr(y) + width;
-                while (src1_ptr < src1_end)
-                {
-                    *dst_ptr++ = BinOp<uchar, opid>::call(*src1_ptr++, *src2_ptr++);
-                }
+                *dst_ptr++ = BinOp<uchar, opid>::call(*src1_ptr++, *src2_ptr++);
             }
         }
     }
+}
 
 
-    template <int opid>
-    void bitwiseBinOp(int rows, int width, const PtrStepb src1, const PtrStepb src2, 
-                      PtrStepb dst, cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(width, threads.x * sizeof(uint)), divUp(rows, threads.y));
+template <int opid>
+void bitwiseBinOp(int rows, int width, const PtrStepb src1, const PtrStepb src2, 
+                  PtrStepb dst, cudaStream_t stream)
+{
+    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() );
+    bitwiseBinOpKernel<opid><<<grid, threads>>>(rows, width, src1, src2, dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0) 
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    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;
+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]) 
-        {
-            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);
+    if (x < cols && y < rows && mask.ptr(y)[x / cn]) 
+    {
+        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);
 
-            dst_row[x] = BinOp<T, opid>::call(src1_row[x], src2_row[x]);
-        }
+        dst_row[x] = BinOp<T, opid>::call(src1_row[x], src2_row[x]);
     }
+}
 
 
-    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)
-    {
-        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() );
+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)
+{
+    dim3 threads(16, 16);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        if (stream == 0) 
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    bitwiseBinOpKernel<T, opid><<<grid, threads>>>(rows, cols, cn, src1, src2, mask, dst);
+    cudaSafeCall( cudaGetLastError() );
 
+    if (stream == 0) 
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, 
-                         const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseBinOp<BIN_OP_OR>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
-    }
 
+void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, 
+                     const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
+{
+    bitwiseBinOp<BIN_OP_OR>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, 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)
-    {
-        bitwiseBinOp<T, BIN_OP_OR>(rows, cols * cn, cn, src1, src2, mask, dst, 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 <typename T>
+void bitwiseMaskOrCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2, 
+                         const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
+{
+    bitwiseBinOp<T, BIN_OP_OR>(rows, cols * cn, cn, src1, src2, mask, dst, 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);
 
-    void bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, 
-                          const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseBinOp<BIN_OP_AND>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
-    }
 
+void bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, 
+                      const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
+{
+    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);
+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);
-    }
 
+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);
+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>
-        {
-        };
-        template <typename F> struct MinMaxTraits<2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct MinMaxTraits<4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 4 };
-            enum { smart_shift = 4 };
-        };
-    }
+//////////////////////////////////////////////////////////////////////////
+// min/max
 
-    template <typename T> struct TransformFunctorTraits< minimum<T> > : detail::MinMaxTraits< sizeof(T), minimum<T> >
-    {
-    };
-    template <typename T> struct TransformFunctorTraits< maximum<T> > : detail::MinMaxTraits< sizeof(T), maximum<T> >
+namespace detail
+{
+    template <size_t size, typename F> struct MinMaxTraits : DefaultTransformFunctorTraits<F>
     {
     };
-    template <typename T> struct TransformFunctorTraits< binder2nd< minimum<T> > > : detail::MinMaxTraits< sizeof(T), binder2nd< minimum<T> > >
+    template <typename F> struct MinMaxTraits<2, F> : DefaultTransformFunctorTraits<F>
     {
+        enum { smart_shift = 4 };
     };
-    template <typename T> struct TransformFunctorTraits< binder2nd< maximum<T> > > : detail::MinMaxTraits< sizeof(T), binder2nd< maximum<T> > >
+    template <typename F> struct MinMaxTraits<4, F> : DefaultTransformFunctorTraits<F>
     {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
     };
-    
-    template <typename T>
-    void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
-    {
-        transform(src1, src2, dst, minimum<T>(), stream);    
-    }
-
-    template void min_gpu<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void min_gpu<schar >(const DevMem2D_<schar>& src1, const DevMem2D_<schar>& src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
-    template void min_gpu<ushort>(const DevMem2D_<ushort>& src1, const DevMem2D_<ushort>& src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
-    template void min_gpu<short >(const DevMem2D_<short>& src1, const DevMem2D_<short>& src2, const DevMem2D_<short>& dst, cudaStream_t stream);
-    template void min_gpu<int   >(const DevMem2D_<int>& src1, const DevMem2D_<int>& src2, const DevMem2D_<int>& dst, cudaStream_t stream);
-    template void min_gpu<float >(const DevMem2D_<float>& src1, const DevMem2D_<float>& src2, const DevMem2D_<float>& dst, cudaStream_t stream);
-    template void min_gpu<double>(const DevMem2D_<double>& src1, const DevMem2D_<double>& src2, const DevMem2D_<double>& dst, cudaStream_t stream);
-
-    template <typename T>
-    void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
-    {
-        transform(src1, src2, dst, maximum<T>(), stream);    
-    }
-    
-    template void max_gpu<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void max_gpu<schar >(const DevMem2D_<schar>& src1, const DevMem2D_<schar>& src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
-    template void max_gpu<ushort>(const DevMem2D_<ushort>& src1, const DevMem2D_<ushort>& src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
-    template void max_gpu<short >(const DevMem2D_<short>& src1, const DevMem2D_<short>& src2, const DevMem2D_<short>& dst, cudaStream_t stream);
-    template void max_gpu<int   >(const DevMem2D_<int>& src1, const DevMem2D_<int>& src2, const DevMem2D_<int>& dst, cudaStream_t stream);
-    template void max_gpu<float >(const DevMem2D_<float>& src1, const DevMem2D_<float>& src2, const DevMem2D_<float>& dst, cudaStream_t stream);
-    template void max_gpu<double>(const DevMem2D_<double>& src1, const DevMem2D_<double>& src2, const DevMem2D_<double>& dst, cudaStream_t stream);
-
-    template <typename T>
-    void min_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream)
-    {
-        transform(src1, dst, device::bind2nd(minimum<T>(), src2), stream);    
-    }
+}
 
-    template void min_gpu<uchar >(const DevMem2Db& src1, uchar src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void min_gpu<schar >(const DevMem2D_<schar>& src1, schar src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
-    template void min_gpu<ushort>(const DevMem2D_<ushort>& src1, ushort src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
-    template void min_gpu<short >(const DevMem2D_<short>& src1, short src2, const DevMem2D_<short>& dst, cudaStream_t stream);
-    template void min_gpu<int   >(const DevMem2D_<int>& src1, int src2, const DevMem2D_<int>& dst, cudaStream_t stream);
-    template void min_gpu<float >(const DevMem2D_<float>& src1, float src2, const DevMem2D_<float>& dst, cudaStream_t stream);
-    template void min_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+template <typename T> struct TransformFunctorTraits< minimum<T> > : detail::MinMaxTraits< sizeof(T), minimum<T> >
+{
+};
+template <typename T> struct TransformFunctorTraits< maximum<T> > : detail::MinMaxTraits< sizeof(T), maximum<T> >
+{
+};
+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> > >
+{
+};
 
-    template <typename T>
-    void max_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream)
-    {
-        transform(src1, dst, device::bind2nd(maximum<T>(), src2), stream);    
-    }
+template <typename T>
+void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    OPENCV_DEVICE_NAMESPACE_ transform(src1, src2, dst, minimum<T>(), stream);    
+}
+
+template void min_gpu<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void min_gpu<schar >(const DevMem2D_<schar>& src1, const DevMem2D_<schar>& src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
+template void min_gpu<ushort>(const DevMem2D_<ushort>& src1, const DevMem2D_<ushort>& src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+template void min_gpu<short >(const DevMem2D_<short>& src1, const DevMem2D_<short>& src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+template void min_gpu<int   >(const DevMem2D_<int>& src1, const DevMem2D_<int>& src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+template void min_gpu<float >(const DevMem2D_<float>& src1, const DevMem2D_<float>& src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+template void min_gpu<double>(const DevMem2D_<double>& src1, const DevMem2D_<double>& src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+
+template <typename T>
+void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    OPENCV_DEVICE_NAMESPACE_ transform(src1, src2, dst, maximum<T>(), stream);    
+}
+
+template void max_gpu<uchar >(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template void max_gpu<schar >(const DevMem2D_<schar>& src1, const DevMem2D_<schar>& src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
+template void max_gpu<ushort>(const DevMem2D_<ushort>& src1, const DevMem2D_<ushort>& src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+template void max_gpu<short >(const DevMem2D_<short>& src1, const DevMem2D_<short>& src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+template void max_gpu<int   >(const DevMem2D_<int>& src1, const DevMem2D_<int>& src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+template void max_gpu<float >(const DevMem2D_<float>& src1, const DevMem2D_<float>& src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+template void max_gpu<double>(const DevMem2D_<double>& src1, const DevMem2D_<double>& src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+
+template <typename T>
+void min_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    OPENCV_DEVICE_NAMESPACE_ transform(src1, dst, device::bind2nd(minimum<T>(), src2), stream);    
+}
+
+template void min_gpu<uchar >(const DevMem2Db& src1, uchar src2, const DevMem2Db& dst, cudaStream_t stream);
+template void min_gpu<schar >(const DevMem2D_<schar>& src1, schar src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
+template void min_gpu<ushort>(const DevMem2D_<ushort>& src1, ushort src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+template void min_gpu<short >(const DevMem2D_<short>& src1, short src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+template void min_gpu<int   >(const DevMem2D_<int>& src1, int src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+template void min_gpu<float >(const DevMem2D_<float>& src1, float src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+template void min_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+
+template <typename T>
+void max_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    OPENCV_DEVICE_NAMESPACE_ transform(src1, dst, device::bind2nd(maximum<T>(), src2), stream);    
+}
 
-    template void max_gpu<uchar >(const DevMem2Db& src1, uchar src2, const DevMem2Db& dst, cudaStream_t stream);
-    template void max_gpu<schar >(const DevMem2D_<schar>& src1, schar src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
-    template void max_gpu<ushort>(const DevMem2D_<ushort>& src1, ushort src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
-    template void max_gpu<short >(const DevMem2D_<short>& src1, short src2, const DevMem2D_<short>& dst, cudaStream_t stream);
-    template void max_gpu<int   >(const DevMem2D_<int>& src1, int src2, const DevMem2D_<int>& dst, cudaStream_t stream);
-    template void max_gpu<float >(const DevMem2D_<float>& src1, float src2, const DevMem2D_<float>& dst, cudaStream_t stream);
-    template void max_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+template void max_gpu<uchar >(const DevMem2Db& src1, uchar src2, const DevMem2Db& dst, cudaStream_t stream);
+template void max_gpu<schar >(const DevMem2D_<schar>& src1, schar src2, const DevMem2D_<schar>& dst, cudaStream_t stream);
+template void max_gpu<ushort>(const DevMem2D_<ushort>& src1, ushort src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+template void max_gpu<short >(const DevMem2D_<short>& src1, short src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+template void max_gpu<int   >(const DevMem2D_<int>& src1, int src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+template void max_gpu<float >(const DevMem2D_<float>& src1, float src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+template void max_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
 
-    
-    //////////////////////////////////////////////////////////////////////////
-    // threshold
 
-    namespace detail
-    {
-        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 };
-        };
-    }
+//////////////////////////////////////////////////////////////////////////
+// threshold
 
-    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> > : detail::ThresholdTraits< sizeof(T), thresh_binary_inv_func<T> >
-    {
-    };
-    template <typename T> struct TransformFunctorTraits< thresh_trunc_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_trunc_func<T> >
+namespace detail
+{
+    template <size_t size, typename F> struct ThresholdTraits : DefaultTransformFunctorTraits<F>
     {
     };
-    template <typename T> struct TransformFunctorTraits< thresh_to_zero_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_to_zero_func<T> >
+    template <typename F> struct ThresholdTraits<2, F> : DefaultTransformFunctorTraits<F>
     {
+        enum { smart_shift = 4 };
     };
-    template <typename T> struct TransformFunctorTraits< thresh_to_zero_inv_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_to_zero_inv_func<T> >
+    template <typename F> struct ThresholdTraits<4, F> : DefaultTransformFunctorTraits<F>
     {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
     };
+}
 
-    template <template <typename> class Op, typename T>
-    void threshold_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, T thresh, T maxVal, 
-        cudaStream_t stream)
-    {
-        Op<T> op(thresh, maxVal);
-        transform(src, dst, op, stream);
-    }
-
-    template <typename T>
-    void threshold_gpu(const DevMem2Db& src, const DevMem2Db& dst, T thresh, T maxVal, int type,
-        cudaStream_t stream)
-    {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, T thresh, T maxVal, 
-            cudaStream_t stream);
+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> > : detail::ThresholdTraits< sizeof(T), thresh_binary_inv_func<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> > : 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> >
+{
+};
 
-        static const caller_t callers[] = 
-        {
-            threshold_caller<thresh_binary_func, T>, 
-            threshold_caller<thresh_binary_inv_func, T>, 
-            threshold_caller<thresh_trunc_func, T>, 
-            threshold_caller<thresh_to_zero_func, T>, 
-            threshold_caller<thresh_to_zero_inv_func, T>
-        };
-
-        callers[type]((DevMem2D_<T>)src, (DevMem2D_<T>)dst, thresh, maxVal, stream);
-    }
+template <template <typename> class Op, typename T>
+void threshold_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, T thresh, T maxVal, 
+    cudaStream_t stream)
+{
+    Op<T> op(thresh, maxVal);
+    OPENCV_DEVICE_NAMESPACE_ transform(src, dst, op, stream);
+}
 
-    template void threshold_gpu<uchar>(const DevMem2Db& src, const DevMem2Db& dst, uchar thresh, uchar maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<schar>(const DevMem2Db& src, const DevMem2Db& dst, schar thresh, schar maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<ushort>(const DevMem2Db& src, const DevMem2Db& dst, ushort thresh, ushort maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<short>(const DevMem2Db& src, const DevMem2Db& dst, short thresh, short maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<int>(const DevMem2Db& src, const DevMem2Db& dst, int thresh, int maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<float>(const DevMem2Db& src, const DevMem2Db& dst, float thresh, float maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<double>(const DevMem2Db& src, const DevMem2Db& dst, double thresh, double maxVal, int type, cudaStream_t stream);
-
-
-
-
-    //////////////////////////////////////////////////////////////////////////
-    // pow
-    
-    template<typename T, bool Signed = device::numeric_limits<T>::is_signed> struct PowOp : unary_function<T, T>
-    {    
-        float power;
-        PowOp(float power_) : power(power_) {}
-            
-        __device__ __forceinline__ T operator()(const T& e) const
-        {      
-            return saturate_cast<T>(__powf((float)e, power));
-        }      
-    };
+template <typename T>
+void threshold_gpu(const DevMem2Db& src, const DevMem2Db& dst, T thresh, T maxVal, int type,
+    cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, T thresh, T maxVal, 
+        cudaStream_t stream);
 
-    template<typename T> struct PowOp<T, true> : unary_function<T, T>
+    static const caller_t callers[] = 
     {
-        float power;
-        PowOp(float power_) : power(power_) {}
-
-        __device__ __forceinline__ float operator()(const T& e) const
-        {
-            T res = saturate_cast<T>(__powf((float)e, power));            
-            
-            if ( (e < 0) && (1 & (int)power) )
-                    res *= -1;            
-            return res;         
-        }
+        threshold_caller<thresh_binary_func, T>, 
+        threshold_caller<thresh_binary_inv_func, T>, 
+        threshold_caller<thresh_trunc_func, T>, 
+        threshold_caller<thresh_to_zero_func, T>, 
+        threshold_caller<thresh_to_zero_inv_func, T>
     };
 
-    template<> struct PowOp<float> : unary_function<float, float>
-    {
-        float power;
-        PowOp(float power_) : power(power_) {}
-
-        __device__ __forceinline__ float operator()(const float& e) const
-        {
-            return __powf(::fabs(e), power);
-        }
-    };
+    callers[type]((DevMem2D_<T>)src, (DevMem2D_<T>)dst, thresh, maxVal, stream);
+}
 
-    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 void threshold_gpu<uchar>(const DevMem2Db& src, const DevMem2Db& dst, uchar thresh, uchar maxVal, int type, cudaStream_t stream);
+template void threshold_gpu<schar>(const DevMem2Db& src, const DevMem2Db& dst, schar thresh, schar maxVal, int type, cudaStream_t stream);
+template void threshold_gpu<ushort>(const DevMem2Db& src, const DevMem2Db& dst, ushort thresh, ushort maxVal, int type, cudaStream_t stream);
+template void threshold_gpu<short>(const DevMem2Db& src, const DevMem2Db& dst, short thresh, short maxVal, int type, cudaStream_t stream);
+template void threshold_gpu<int>(const DevMem2Db& src, const DevMem2Db& dst, int thresh, int maxVal, int type, cudaStream_t stream);
+template void threshold_gpu<float>(const DevMem2Db& src, const DevMem2Db& dst, float thresh, float maxVal, int type, cudaStream_t stream);
+template void threshold_gpu<double>(const DevMem2Db& src, const DevMem2Db& dst, double thresh, double maxVal, int type, cudaStream_t stream);
 
-    template <typename T> struct TransformFunctorTraits< PowOp<T> > : detail::PowOpTraits<sizeof(T), T>
-    {
-    };
 
-    template<typename T>
-    void pow_caller(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream)
-    {
-        transform((DevMem2D_<T>)src, (DevMem2D_<T>)dst, PowOp<T>(power), stream);
-    }   
 
-    template void pow_caller<uchar>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
-    template void pow_caller<schar>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
-    template void pow_caller<short>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
-    template void pow_caller<ushort>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
-    template void pow_caller<int>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
-    template void pow_caller<float>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
 
+//////////////////////////////////////////////////////////////////////////
+// pow
 
-    
+template<typename T, bool Signed = device::numeric_limits<T>::is_signed> struct PowOp : unary_function<T, T>
+{    
+    float power;
+    PowOp(float power_) : power(power_) {}
+        
+    __device__ __forceinline__ T operator()(const T& e) const
+    {      
+        return saturate_cast<T>(__powf((float)e, power));
+    }      
+};
 
-    //////////////////////////////////////////////////////////////////////////
-    // addWeighted
+template<typename T> struct PowOp<T, true> : unary_function<T, T>
+{
+    float power;
+    PowOp(float power_) : power(power_) {}
 
-    template <typename T1, typename T2, typename D> struct AddWeighted : binary_function<T1, T2, D>
+    __device__ __forceinline__ float operator()(const T& e) const
     {
-        __host__ __device__ __forceinline__ AddWeighted(double alpha_, double beta_, double gamma_) : alpha(alpha_), beta(beta_), gamma(gamma_) {}
-
-        __device__ __forceinline__ D operator ()(typename TypeTraits<T1>::ParameterType a, typename TypeTraits<T2>::ParameterType b) const
-        {
-            return saturate_cast<D>(alpha * a + beta * b + gamma);
-        }
+        T res = saturate_cast<T>(__powf((float)e, power));            
+        
+        if ( (e < 0) && (1 & (int)power) )
+                res *= -1;            
+        return res;         
+    }
+};
 
-        const double alpha;
-        const double beta;
-        const double gamma;
-    };
+template<> struct PowOp<float> : unary_function<float, float>
+{
+    float power;
+    PowOp(float power_) : power(power_) {}
 
-    template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, ushort> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, short> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, short> >
-    {
-        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> >
+    __device__ __forceinline__ float operator()(const float& e) const
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<short, short, short> > : DefaultTransformFunctorTraits< AddWeighted<short, short, short> >
-    {
-        enum { smart_shift = 4 };
-    };
+        return __powf(::fabs(e), power);
+    }
+};
 
-    template <> struct TransformFunctorTraits< AddWeighted<int, int, int> > : DefaultTransformFunctorTraits< AddWeighted<int, int, int> >
-    {
-        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> >
+namespace detail
+{
+    template <size_t size, typename T> struct PowOpTraits : DefaultTransformFunctorTraits< PowOp<T> >
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AddWeighted<int, float, float> > : DefaultTransformFunctorTraits< AddWeighted<int, float, float> >
+    template <typename T> struct PowOpTraits<1, T> : DefaultTransformFunctorTraits< PowOp<T> >
     {
         enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
+        enum { smart_shift = 8 };
     };
-    template <> struct TransformFunctorTraits< AddWeighted<float, float, int> > : DefaultTransformFunctorTraits< AddWeighted<float, float, float> >
+    template <typename T> struct PowOpTraits<2, T> : DefaultTransformFunctorTraits< PowOp<T> >
     {
-        enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AddWeighted<float, float, float> > : DefaultTransformFunctorTraits< AddWeighted<float, float, float> >
+    template <typename T> struct PowOpTraits<4, T> : DefaultTransformFunctorTraits< PowOp<T> >
     {
-        enum { smart_block_dim_y = 8 };
+        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>
+void pow_caller(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream)
+{
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src, (DevMem2D_<T>)dst, PowOp<T>(power), stream);
+}   
+
+template void pow_caller<uchar>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+template void pow_caller<schar>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+template void pow_caller<short>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+template void pow_caller<ushort>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+template void pow_caller<int>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+template void pow_caller<float>(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+
 
-    template <typename T1, typename T2, typename D>
-    void addWeighted_gpu(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream)
-    {
-        cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
-        cudaSafeCall( cudaSetDoubleForDevice(&beta) );
-        cudaSafeCall( cudaSetDoubleForDevice(&gamma) );
 
-        AddWeighted<T1, T2, D> op(alpha, beta, gamma);
 
-        transform(static_cast< DevMem2D_<T1> >(src1), static_cast< DevMem2D_<T2> >(src2), static_cast< DevMem2D_<D> >(dst), op, stream);
+//////////////////////////////////////////////////////////////////////////
+// addWeighted
+
+template <typename T1, typename T2, typename D> struct AddWeighted : binary_function<T1, T2, D>
+{
+    __host__ __device__ __forceinline__ AddWeighted(double alpha_, double beta_, double gamma_) : alpha(alpha_), beta(beta_), gamma(gamma_) {}
+
+    __device__ __forceinline__ D operator ()(typename TypeTraits<T1>::ParameterType a, typename TypeTraits<T2>::ParameterType b) const
+    {
+        return saturate_cast<D>(alpha * a + beta * b + gamma);
     }
 
-    template void addWeighted_gpu<uchar, uchar, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<uchar, schar, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<uchar, ushort, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<uchar, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<uchar, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<uchar, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<uchar, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-
-
-    template void addWeighted_gpu<schar, schar, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<schar, ushort, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<schar, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<schar, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<schar, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<schar, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-
-
-    template void addWeighted_gpu<ushort, ushort, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<ushort, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<ushort, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<ushort, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<ushort, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-
-
-    template void addWeighted_gpu<short, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<short, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<short, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<short, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    
-
-    template void addWeighted_gpu<int, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<int, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<int, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    
-
-    template void addWeighted_gpu<float, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    template void addWeighted_gpu<float, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-
-    
-
-    template void addWeighted_gpu<double, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-}}}
+    const double alpha;
+    const double beta;
+    const double gamma;
+};
+
+template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, ushort> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, ushort> >
+{
+    enum { smart_shift = 4 };
+};
+template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, short> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, short> >
+{
+    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> >
+{
+    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 };
+};
+
+template <typename T1, typename T2, typename D>
+void addWeighted_gpu(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
+    cudaSafeCall( cudaSetDoubleForDevice(&beta) );
+    cudaSafeCall( cudaSetDoubleForDevice(&gamma) );
+
+    AddWeighted<T1, T2, D> op(alpha, beta, gamma);
+
+    OPENCV_DEVICE_NAMESPACE_ transform(static_cast< DevMem2D_<T1> >(src1), static_cast< DevMem2D_<T2> >(src2), static_cast< DevMem2D_<D> >(dst), op, stream);
+}
+
+template void addWeighted_gpu<uchar, uchar, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, uchar, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, uchar, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, uchar, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, uchar, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, uchar, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, uchar, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<uchar, schar, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, schar, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, schar, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, schar, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, schar, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, schar, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, schar, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<uchar, ushort, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, ushort, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, ushort, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, ushort, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, ushort, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, ushort, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, ushort, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<uchar, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<uchar, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<uchar, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<uchar, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<uchar, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+
+
+template void addWeighted_gpu<schar, schar, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, schar, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, schar, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, schar, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, schar, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, schar, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, schar, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<schar, ushort, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, ushort, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, ushort, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, ushort, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, ushort, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, ushort, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, ushort, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<schar, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<schar, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<schar, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<schar, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<schar, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+
+
+template void addWeighted_gpu<ushort, ushort, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, ushort, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, ushort, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, ushort, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, ushort, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, ushort, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, ushort, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<ushort, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<ushort, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<ushort, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<ushort, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<ushort, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+
+
+template void addWeighted_gpu<short, short, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, short, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, short, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, short, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, short, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, short, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, short, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<short, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<short, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<short, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<short, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+
+
+template void addWeighted_gpu<int, int, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, int, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, int, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, int, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, int, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, int, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, int, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<int, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<int, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<int, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+
+
+template void addWeighted_gpu<float, float, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, float, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, float, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, float, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, float, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, float, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, float, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+template void addWeighted_gpu<float, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<float, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+
+
+template void addWeighted_gpu<double, double, uchar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<double, double, schar>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<double, double, ushort>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<double, double, short>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<double, double, int>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<double, double, float>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+template void addWeighted_gpu<double, double, double>(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/hist.cu b/modules/gpu/src/cuda/hist.cu
index c420c9735d8747650bb06350dc2c7fa57dfd67e9..52d6154c9802d3777b7f1e37a4f476622bd50194 100644
--- a/modules/gpu/src/cuda/hist.cu
+++ b/modules/gpu/src/cuda/hist.cu
@@ -45,9 +45,7 @@
 #include "opencv2/gpu/device/utility.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-using namespace cv::gpu;
-
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
 #define UINT_BITS 32U
 
@@ -67,154 +65,157 @@ using namespace cv::gpu::device;
 
 #define USE_SMEM_ATOMICS (__CUDA_ARCH__ >= 120)
 
-namespace cv { namespace gpu { namespace histograms
-{
-    #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);
-        }
+namespace hist {
 
-    #else
+#if (!USE_SMEM_ATOMICS)
 
-        #define TAG_MASK 0xFFFFFFFFU
+    #define TAG_MASK ( (1U << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE)) - 1U )
 
-        __forceinline__ __device__ void addByte(uint* s_WarpHist, uint data, uint threadTag)
+    __forceinline__ __device__ void addByte(volatile uint* s_WarpHist, uint data, uint threadTag)
+    {
+        uint count;
+        do
         {
-            atomicAdd(s_WarpHist + data, 1);
-        }
+            count = s_WarpHist[data] & TAG_MASK;
+            count = threadTag | (count + 1);
+            s_WarpHist[data] = count;
+        } while (s_WarpHist[data] != count);
+    }
 
-    #endif
+#else
 
-    __forceinline__ __device__ void addWord(uint* s_WarpHist, uint data, uint tag, uint pos_x, uint cols)
-    {
-        uint x = pos_x << 2;
+    #define TAG_MASK 0xFFFFFFFFU
 
-        if (x + 0 < cols) addByte(s_WarpHist, (data >>  0) & 0xFFU, tag);
-        if (x + 1 < cols) addByte(s_WarpHist, (data >>  8) & 0xFFU, tag);
-        if (x + 2 < cols) addByte(s_WarpHist, (data >> 16) & 0xFFU, tag);
-        if (x + 3 < cols) addByte(s_WarpHist, (data >> 24) & 0xFFU, tag);
+    __forceinline__ __device__ void addByte(uint* s_WarpHist, uint data, uint threadTag)
+    {
+        atomicAdd(s_WarpHist + data, 1);
     }
 
-    __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;
+#endif
 
-        //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;
+__forceinline__ __device__ void addWord(uint* s_WarpHist, uint data, uint tag, uint pos_x, uint cols)
+{
+    uint x = pos_x << 2;
 
-        //Cycle through the entire data set, update subhistograms for each warp
-        const uint tag = threadIdx.x << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE);
+    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);
+}
 
-        __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);
-        }
+__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;
 
-        //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;
+    //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;
 
-            for (uint i = 0; i < WARP_COUNT; i++)
-                sum += s_Hist[bin + i * HISTOGRAM256_BIN_COUNT] & TAG_MASK;
+    //Cycle through the entire data set, update subhistograms for each warp
+    const uint tag = threadIdx.x << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE);
 
-            d_PartialHistograms[blockIdx.x * HISTOGRAM256_BIN_COUNT + bin] = sum;
-        }
+    __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 histogram256() output
-    // Run one threadblock per bin; each threadblock adds up the same bin counter
-    // from every partial histogram. Reads are uncoalesced, but mergeHistogram256
-    // takes only a fraction of total processing time
-    ////////////////////////////////////////////////////////////////////////////////
-
-    __global__ void mergeHistogram256(const uint* d_PartialHistograms, int* d_Histogram)
+    //Merge per-warp histograms into per-block and write to global memory
+    __syncthreads();
+    for(uint bin = threadIdx.x; bin < HISTOGRAM256_BIN_COUNT; bin += HISTOGRAM256_THREADBLOCK_SIZE)
     {
         uint sum = 0;
 
-        #pragma unroll
-        for (uint i = threadIdx.x; i < PARTIAL_HISTOGRAM256_COUNT; i += MERGE_THREADBLOCK_SIZE)
-            sum += d_PartialHistograms[blockIdx.x + i * HISTOGRAM256_BIN_COUNT];
+        for (uint i = 0; i < WARP_COUNT; i++)
+            sum += s_Hist[bin + i * HISTOGRAM256_BIN_COUNT] & TAG_MASK;
 
-        __shared__ uint data[MERGE_THREADBLOCK_SIZE];
-        data[threadIdx.x] = sum;
+        d_PartialHistograms[blockIdx.x * HISTOGRAM256_BIN_COUNT + bin] = sum;
+    }
+}
 
-        for (uint stride = MERGE_THREADBLOCK_SIZE / 2; stride > 0; stride >>= 1)
-        {
-            __syncthreads();
-            if(threadIdx.x < stride)
-                data[threadIdx.x] += data[threadIdx.x + stride];
-        }
+////////////////////////////////////////////////////////////////////////////////
+// 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
+////////////////////////////////////////////////////////////////////////////////
 
-        if(threadIdx.x == 0)
-            d_Histogram[blockIdx.x] = saturate_cast<int>(data[0]);
-    }
+__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];
 
-    void histogram256_gpu(DevMem2Db src, int* hist, uint* buf, cudaStream_t stream)
+    __shared__ uint data[MERGE_THREADBLOCK_SIZE];
+    data[threadIdx.x] = sum;
+
+    for (uint stride = MERGE_THREADBLOCK_SIZE / 2; stride > 0; stride >>= 1)
     {
-        histogram256<<<PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_THREADBLOCK_SIZE, 0, stream>>>(
-            DevMem2D_<uint>(src),
-            buf, 
-            static_cast<uint>(src.rows * src.step / sizeof(uint)),
-            src.cols);
+        __syncthreads();
+        if(threadIdx.x < stride)
+            data[threadIdx.x] += data[threadIdx.x + stride];
+    }
 
-        cudaSafeCall( cudaGetLastError() );
+    if(threadIdx.x == 0)
+        d_Histogram[blockIdx.x] = saturate_cast<int>(data[0]);
+}
 
-        mergeHistogram256<<<HISTOGRAM256_BIN_COUNT, MERGE_THREADBLOCK_SIZE, 0, stream>>>(buf, hist);
+void histogram256_gpu(DevMem2Db src, int* hist, uint* buf, cudaStream_t stream)
+{
+    histogram256<<<PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_THREADBLOCK_SIZE, 0, stream>>>(
+        DevMem2D_<uint>(src),
+        buf, 
+        static_cast<uint>(src.rows * src.step / sizeof(uint)),
+        src.cols);
 
-        cudaSafeCall( cudaGetLastError() );
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    mergeHistogram256<<<HISTOGRAM256_BIN_COUNT, MERGE_THREADBLOCK_SIZE, 0, stream>>>(buf, hist);
 
-    __constant__ int c_lut[256];
+    cudaSafeCall( cudaGetLastError() );
 
-    __global__ void equalizeHist(const DevMem2Db src, PtrStepb dst)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-        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);
-        }
-    }
+__constant__ int c_lut[256];
+
+__global__ void equalizeHist(const DevMem2Db src, PtrStepb dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-    void equalizeHist_gpu(DevMem2Db src, DevMem2Db dst, const int* lut, cudaStream_t stream)
+    if (x < src.cols && y < src.rows)
     {
-        dim3 block(16, 16);
-        dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+        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);
+    }
+}
 
-        cudaSafeCall( cudaMemcpyToSymbol(cv::gpu::histograms::c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice) );
+void equalizeHist_gpu(DevMem2Db src, DevMem2Db dst, const int* lut, cudaStream_t stream)
+{
+    dim3 block(16, 16);
+    dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
 
-        equalizeHist<<<grid, block, 0, stream>>>(src, dst);
-        cudaSafeCall( cudaGetLastError() );
+    cudaSafeCall( cudaMemcpyToSymbol(c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice) );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-}}}
+    equalizeHist<<<grid, block, 0, stream>>>(src, dst);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+} // namespace hist
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/hog.cu b/modules/gpu/src/cuda/hog.cu
index 8ac6196a6da781cb03c7c945c330e578187e0bc5..db43d74bc80dbb812e335a90ef76a6a76569e082 100644
--- a/modules/gpu/src/cuda/hog.cu
+++ b/modules/gpu/src/cuda/hog.cu
@@ -42,13 +42,15 @@
 
 #include "internal_shared.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
 // Other values are not supported
 #define CELL_WIDTH 8
 #define CELL_HEIGHT 8
 #define CELLS_PER_BLOCK_X 2
 #define CELLS_PER_BLOCK_Y 2
 
-namespace cv { namespace gpu { namespace hog {
+namespace hog {
 
 __constant__ int cnbins;
 __constant__ int cblock_stride_x;
@@ -83,23 +85,23 @@ int power_2up(unsigned int n)
 void set_up_constants(int nbins, int block_stride_x, int block_stride_y, 
                       int nblocks_win_x, int nblocks_win_y)
 {
-    uploadConstant("cv::gpu::hog::cnbins", nbins);
-    uploadConstant("cv::gpu::hog::cblock_stride_x", block_stride_x);
-    uploadConstant("cv::gpu::hog::cblock_stride_y", block_stride_y);
-    uploadConstant("cv::gpu::hog::cnblocks_win_x", nblocks_win_x);
-    uploadConstant("cv::gpu::hog::cnblocks_win_y", nblocks_win_y);
+    cudaSafeCall( cudaMemcpyToSymbol(cnbins, &nbins, sizeof(nbins)) ); 
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_stride_x, &block_stride_x, sizeof(block_stride_x)) ); 
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_stride_y, &block_stride_y, sizeof(block_stride_y)) ); 
+    cudaSafeCall( cudaMemcpyToSymbol(cnblocks_win_x, &nblocks_win_x, sizeof(nblocks_win_x)) );  
+    cudaSafeCall( cudaMemcpyToSymbol(cnblocks_win_y, &nblocks_win_y, sizeof(nblocks_win_y)) ); 
 
-    int block_hist_size = nbins * CELLS_PER_BLOCK_X * CELLS_PER_BLOCK_Y;
-    uploadConstant("cv::gpu::hog::cblock_hist_size", block_hist_size);
+    int block_hist_size = nbins * CELLS_PER_BLOCK_X * CELLS_PER_BLOCK_Y; 
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_hist_size, &block_hist_size, sizeof(block_hist_size)) ); 
 
-    int block_hist_size_2up = power_2up(block_hist_size);    
-    uploadConstant("cv::gpu::hog::cblock_hist_size_2up", block_hist_size_2up);
+    int block_hist_size_2up = power_2up(block_hist_size);  
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_hist_size_2up, &block_hist_size_2up, sizeof(block_hist_size_2up)) );
 
     int descr_width = nblocks_win_x * block_hist_size;
-    uploadConstant("cv::gpu::hog::cdescr_width", descr_width);
+    cudaSafeCall( cudaMemcpyToSymbol(cdescr_width, &descr_width, sizeof(descr_width)) );
 
     int descr_size = descr_width * nblocks_win_y;
-    uploadConstant("cv::gpu::hog::cdescr_size", descr_size);
+    cudaSafeCall( cudaMemcpyToSymbol(cdescr_size, &descr_size, sizeof(descr_size)) );
 }
 
 
@@ -153,10 +155,10 @@ __global__ void compute_hists_kernel_many_blocks(const int img_block_width, cons
             int dist_center_y = dist_y - 4 * (1 - 2 * cell_y);
             int dist_center_x = dist_x - 4 * (1 - 2 * cell_x);
 
-            float gaussian = expf(-(dist_center_y * dist_center_y + 
-                                    dist_center_x * dist_center_x) * scale);
-            float interp_weight = (8.f - fabs(dist_y + 0.5f)) * 
-                                  (8.f - fabs(dist_x + 0.5f)) / 64.f;
+            float gaussian = ::expf(-(dist_center_y * dist_center_y + 
+                                      dist_center_x * dist_center_x) * scale);
+            float interp_weight = (8.f - ::fabs(dist_y + 0.5f)) * 
+                                  (8.f - ::fabs(dist_x + 0.5f)) / 64.f;
 
             hist[bin.x * 48 * nblocks] += gaussian * interp_weight * vote.x;
             hist[bin.y * 48 * nblocks] += gaussian * interp_weight * vote.y;
@@ -273,15 +275,15 @@ __global__ void normalize_hists_kernel_many_blocks(const int block_hist_size,
     __syncthreads();
     float sum = reduce_smem<nthreads>(squares);
     
-    float scale = 1.0f / (sqrtf(sum) + 0.1f * block_hist_size);        
-    elem = min(elem * scale, threshold);
+    float scale = 1.0f / (::sqrtf(sum) + 0.1f * block_hist_size);        
+    elem = ::min(elem * scale, threshold);
     
     __syncthreads();
     squares[threadIdx.x] = elem * elem;
 
     __syncthreads();
     sum = reduce_smem<nthreads>(squares);
-    scale = 1.0f / (sqrtf(sum) + 1e-3f);
+    scale = 1.0f / (::sqrtf(sum) + 1e-3f);
     
     if (threadIdx.x < block_hist_size)
         hist[0] = elem * scale;
@@ -533,7 +535,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
 
     if (threadIdx.x == 0)
     {
-        val = row[max(x - 1, 1)];
+        val = row[::max(x - 1, 1)];
         sh_row[0] = val.x;
         sh_row[(nthreads + 2)] = val.y;
         sh_row[2 * (nthreads + 2)] = val.z;
@@ -541,7 +543,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
 
     if (threadIdx.x == blockDim.x - 1)
     {
-        val = row[min(x + 1, width - 2)];
+        val = row[::min(x + 1, width - 2)];
         sh_row[blockDim.x + 1] = val.x;
         sh_row[blockDim.x + 1 + (nthreads + 2)] = val.y;
         sh_row[blockDim.x + 1 + 2 * (nthreads + 2)] = val.z;
@@ -561,7 +563,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
 
         float3 dx;
         if (correct_gamma)
-            dx = make_float3(sqrtf(b.x) - sqrtf(a.x), sqrtf(b.y) - sqrtf(a.y), sqrtf(b.z) - sqrtf(a.z));    
+            dx = make_float3(::sqrtf(b.x) - ::sqrtf(a.x), ::sqrtf(b.y) - ::sqrtf(a.y), ::sqrtf(b.z) - ::sqrtf(a.z));    
         else
             dx = make_float3(b.x - a.x, b.y - a.y, b.z - a.z);    
 
@@ -576,7 +578,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
             b = make_float3(val.x, val.y, val.z);
 
             if (correct_gamma)
-                dy = make_float3(sqrtf(b.x) - sqrtf(a.x), sqrtf(b.y) - sqrtf(a.y), sqrtf(b.z) - sqrtf(a.z));
+                dy = make_float3(::sqrtf(b.x) - ::sqrtf(a.x), ::sqrtf(b.y) - ::sqrtf(a.y), ::sqrtf(b.z) - ::sqrtf(a.z));
             else
                 dy = make_float3(b.x - a.x, b.y - a.y, b.z - a.z);
         }
@@ -601,10 +603,10 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
             mag0 = mag1;
         }
 
-        mag0 = sqrtf(mag0);
+        mag0 = ::sqrtf(mag0);
 
-        float ang = (atan2f(best_dy, best_dx) + CV_PI_F) * angle_scale - 0.5f;
-        int hidx = (int)floorf(ang);
+        float ang = (::atan2f(best_dy, best_dx) + CV_PI_F) * angle_scale - 0.5f;
+        int hidx = (int)::floorf(ang);
         ang -= hidx;
         hidx = (hidx + cnbins) % cnbins;
 
@@ -648,10 +650,10 @@ __global__ void compute_gradients_8UC1_kernel(int height, int width, const PtrEl
         sh_row[threadIdx.x + 1] = row[width - 2];
 
     if (threadIdx.x == 0)
-        sh_row[0] = row[max(x - 1, 1)];
+        sh_row[0] = row[::max(x - 1, 1)];
 
     if (threadIdx.x == blockDim.x - 1)
-        sh_row[blockDim.x + 1] = row[min(x + 1, width - 2)];
+        sh_row[blockDim.x + 1] = row[::min(x + 1, width - 2)];
 
     __syncthreads();
     if (x < width)
@@ -659,7 +661,7 @@ __global__ void compute_gradients_8UC1_kernel(int height, int width, const PtrEl
         float dx;
 
         if (correct_gamma)
-            dx = sqrtf(sh_row[threadIdx.x + 2]) - sqrtf(sh_row[threadIdx.x]);
+            dx = ::sqrtf(sh_row[threadIdx.x + 2]) - ::sqrtf(sh_row[threadIdx.x]);
         else
             dx = sh_row[threadIdx.x + 2] - sh_row[threadIdx.x];
 
@@ -669,14 +671,14 @@ __global__ void compute_gradients_8UC1_kernel(int height, int width, const PtrEl
             float a = ((const unsigned char*)img.ptr(blockIdx.y + 1))[x];
             float b = ((const unsigned char*)img.ptr(blockIdx.y - 1))[x];
             if (correct_gamma)
-                dy = sqrtf(a) - sqrtf(b);
+                dy = ::sqrtf(a) - ::sqrtf(b);
             else
                 dy = a - b;
         }
-        float mag = sqrtf(dx * dx + dy * dy);
+        float mag = ::sqrtf(dx * dx + dy * dy);
 
-        float ang = (atan2f(dy, dx) + CV_PI_F) * angle_scale - 0.5f;
-        int hidx = (int)floorf(ang);
+        float ang = (::atan2f(dy, dx) + CV_PI_F) * angle_scale - 0.5f;
+        int hidx = (int)::floorf(ang);
         ang -= hidx;
         hidx = (hidx + cnbins) % cnbins;
 
@@ -768,4 +770,6 @@ static void resize_for_hog(const DevMem2Db& src, DevMem2Db dst, TEX& tex)
 void resize_8UC1(const DevMem2Db& src, DevMem2Db dst) { resize_for_hog<uchar> (src, dst, resize8UC1_tex); }
 void resize_8UC4(const DevMem2Db& src, DevMem2Db dst) { resize_for_hog<uchar4>(src, dst, resize8UC4_tex); }
 
-}}}
+} // namespace hog 
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/imgproc.cu b/modules/gpu/src/cuda/imgproc.cu
index 7b83362e1f8465f7b710a47715ad944e5da208f4..0169566045649d1febf9b9016db8bff25ed3bba9 100644
--- a/modules/gpu/src/cuda/imgproc.cu
+++ b/modules/gpu/src/cuda/imgproc.cu
@@ -46,992 +46,990 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc {
 
-namespace cv { namespace gpu { namespace imgproc
-{
 /////////////////////////////////// MeanShiftfiltering ///////////////////////////////////////////////
 
-    texture<uchar4, 2> tex_meanshift;
+texture<uchar4, 2> tex_meanshift;
+
+__device__ short2 do_mean_shift(int x0, int y0, unsigned char* out, 
+                                size_t out_step, int cols, int rows, 
+                                int sp, int sr, int maxIter, float eps)
+{
+    int isr2 = sr*sr;
+    uchar4 c = tex2D(tex_meanshift, x0, y0 );
 
-    __device__ short2 do_mean_shift(int x0, int y0, unsigned char* out, 
-                                    size_t out_step, int cols, int rows, 
-                                    int sp, int sr, int maxIter, float eps)
+    // iterate meanshift procedure
+    for( int iter = 0; iter < maxIter; iter++ )
     {
-        int isr2 = sr*sr;
-        uchar4 c = tex2D(tex_meanshift, x0, y0 );
+        int count = 0;
+        int s0 = 0, s1 = 0, s2 = 0, sx = 0, sy = 0;
+        float icount;
 
-        // iterate meanshift procedure
-        for( int iter = 0; iter < maxIter; iter++ )
-        {
-            int count = 0;
-            int s0 = 0, s1 = 0, s2 = 0, sx = 0, sy = 0;
-            float icount;
+        //mean shift: process pixels in window (p-sigmaSp)x(p+sigmaSp)
+        int minx = x0-sp;
+        int miny = y0-sp;
+        int maxx = x0+sp;
+        int maxy = y0+sp;
 
-            //mean shift: process pixels in window (p-sigmaSp)x(p+sigmaSp)
-            int minx = x0-sp;
-            int miny = y0-sp;
-            int maxx = x0+sp;
-            int maxy = y0+sp;
+        for( int y = miny; y <= maxy; y++)
+        {
+            int rowCount = 0;
+            for( int x = minx; x <= maxx; x++ )
+            {                    
+                uchar4 t = tex2D( tex_meanshift, x, y );
 
-            for( int y = miny; y <= maxy; y++)
-            {
-                int rowCount = 0;
-                for( int x = minx; x <= maxx; x++ )
-                {                    
-                    uchar4 t = tex2D( tex_meanshift, x, y );
-
-                    int norm2 = (t.x - c.x) * (t.x - c.x) + (t.y - c.y) * (t.y - c.y) + (t.z - c.z) * (t.z - c.z);
-                    if( norm2 <= isr2 )
-                    {
-                        s0 += t.x; s1 += t.y; s2 += t.z;
-                        sx += x; rowCount++;
-                    }
+                int norm2 = (t.x - c.x) * (t.x - c.x) + (t.y - c.y) * (t.y - c.y) + (t.z - c.z) * (t.z - c.z);
+                if( norm2 <= isr2 )
+                {
+                    s0 += t.x; s1 += t.y; s2 += t.z;
+                    sx += x; rowCount++;
                 }
-                count += rowCount;
-                sy += y*rowCount;
             }
+            count += rowCount;
+            sy += y*rowCount;
+        }
 
-            if( count == 0 )
-                break;
+        if( count == 0 )
+            break;
 
-            icount = 1.f/count;
-            int x1 = __float2int_rz(sx*icount);
-            int y1 = __float2int_rz(sy*icount);
-            s0 = __float2int_rz(s0*icount);
-            s1 = __float2int_rz(s1*icount);
-            s2 = __float2int_rz(s2*icount);
+        icount = 1.f/count;
+        int x1 = __float2int_rz(sx*icount);
+        int y1 = __float2int_rz(sy*icount);
+        s0 = __float2int_rz(s0*icount);
+        s1 = __float2int_rz(s1*icount);
+        s2 = __float2int_rz(s2*icount);
 
-            int norm2 = (s0 - c.x) * (s0 - c.x) + (s1 - c.y) * (s1 - c.y) + (s2 - c.z) * (s2 - c.z);
+        int norm2 = (s0 - c.x) * (s0 - c.x) + (s1 - c.y) * (s1 - c.y) + (s2 - c.z) * (s2 - c.z);
 
-            bool stopFlag = (x0 == x1 && y0 == y1) || (abs(x1-x0) + abs(y1-y0) + norm2 <= eps);
+        bool stopFlag = (x0 == x1 && y0 == y1) || (::abs(x1-x0) + ::abs(y1-y0) + norm2 <= eps);
 
-            x0 = x1; y0 = y1;
-            c.x = s0; c.y = s1; c.z = s2;
+        x0 = x1; y0 = y1;
+        c.x = s0; c.y = s1; c.z = s2;
 
-            if( stopFlag )
-                break;
-        }
+        if( stopFlag )
+            break;
+    }
 
-        int base = (blockIdx.y * blockDim.y + threadIdx.y) * out_step + (blockIdx.x * blockDim.x + threadIdx.x) * 4 * sizeof(uchar);
-        *(uchar4*)(out + base) = c;
+    int base = (blockIdx.y * blockDim.y + threadIdx.y) * out_step + (blockIdx.x * blockDim.x + threadIdx.x) * 4 * sizeof(uchar);
+    *(uchar4*)(out + base) = c;
 
-        return make_short2((short)x0, (short)y0);
-    }
+    return make_short2((short)x0, (short)y0);
+}
 
-    __global__ void meanshift_kernel(unsigned char* out, size_t out_step, int cols, int rows, int sp, int sr, int maxIter, float eps )
-    {
-        int x0 = blockIdx.x * blockDim.x + threadIdx.x;
-        int y0 = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void meanshift_kernel(unsigned char* out, size_t out_step, int cols, int rows, int sp, int sr, int maxIter, float eps )
+{
+    int x0 = blockIdx.x * blockDim.x + threadIdx.x;
+    int y0 = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if( x0 < cols && y0 < rows )
-            do_mean_shift(x0, y0, out, out_step, cols, rows, sp, sr, maxIter, eps);
-    }
+    if( x0 < cols && y0 < rows )
+        do_mean_shift(x0, y0, out, out_step, cols, rows, sp, sr, maxIter, eps);
+}
 
-    __global__ void meanshiftproc_kernel(unsigned char* outr, size_t outrstep, 
-                                         unsigned char* outsp, size_t outspstep, 
-                                         int cols, int rows, 
-                                         int sp, int sr, int maxIter, float eps)
-    {
-        int x0 = blockIdx.x * blockDim.x + threadIdx.x;
-        int y0 = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void meanshiftproc_kernel(unsigned char* outr, size_t outrstep, 
+                                     unsigned char* outsp, size_t outspstep, 
+                                     int cols, int rows, 
+                                     int sp, int sr, int maxIter, float eps)
+{
+    int x0 = blockIdx.x * blockDim.x + threadIdx.x;
+    int y0 = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if( x0 < cols && y0 < rows )
-        {            
-            int basesp = (blockIdx.y * blockDim.y + threadIdx.y) * outspstep + (blockIdx.x * blockDim.x + threadIdx.x) * 2 * sizeof(short);
-            *(short2*)(outsp + basesp) = do_mean_shift(x0, y0, outr, outrstep, cols, rows, sp, sr, maxIter, eps);
-        }
+    if( x0 < cols && y0 < rows )
+    {            
+        int basesp = (blockIdx.y * blockDim.y + threadIdx.y) * outspstep + (blockIdx.x * blockDim.x + threadIdx.x) * 2 * sizeof(short);
+        *(short2*)(outsp + basesp) = do_mean_shift(x0, y0, outr, outrstep, cols, rows, sp, sr, maxIter, eps);
     }
+}
 
-    void meanShiftFiltering_gpu(const DevMem2Db& src, DevMem2Db dst, int sp, int sr, int maxIter, float eps, cudaStream_t stream)
-    {
-        dim3 grid(1, 1, 1);
-        dim3 threads(32, 8, 1);
-        grid.x = divUp(src.cols, threads.x);
-        grid.y = divUp(src.rows, threads.y);
+void meanShiftFiltering_gpu(const DevMem2Db& src, DevMem2Db dst, int sp, int sr, int maxIter, float eps, cudaStream_t stream)
+{
+    dim3 grid(1, 1, 1);
+    dim3 threads(32, 8, 1);
+    grid.x = divUp(src.cols, threads.x);
+    grid.y = divUp(src.rows, threads.y);
 
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar4>();
-        cudaSafeCall( cudaBindTexture2D( 0, tex_meanshift, src.data, desc, src.cols, src.rows, src.step ) );
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar4>();
+    cudaSafeCall( cudaBindTexture2D( 0, tex_meanshift, src.data, desc, src.cols, src.rows, src.step ) );
 
-        meanshift_kernel<<< grid, threads, 0, stream >>>( dst.data, dst.step, dst.cols, dst.rows, sp, sr, maxIter, eps );
-        cudaSafeCall( cudaGetLastError() );
+    meanshift_kernel<<< grid, threads, 0, stream >>>( dst.data, dst.step, dst.cols, dst.rows, sp, sr, maxIter, eps );
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
 
-        //cudaSafeCall( cudaUnbindTexture( tex_meanshift ) );        
-    }
+    //cudaSafeCall( cudaUnbindTexture( tex_meanshift ) );        
+}
 
-    void meanShiftProc_gpu(const DevMem2Db& src, DevMem2Db dstr, DevMem2Db dstsp, int sp, int sr, int maxIter, float eps, cudaStream_t stream) 
-    {
-        dim3 grid(1, 1, 1);
-        dim3 threads(32, 8, 1);
-        grid.x = divUp(src.cols, threads.x);
-        grid.y = divUp(src.rows, threads.y);
+void meanShiftProc_gpu(const DevMem2Db& src, DevMem2Db dstr, DevMem2Db dstsp, int sp, int sr, int maxIter, float eps, cudaStream_t stream) 
+{
+    dim3 grid(1, 1, 1);
+    dim3 threads(32, 8, 1);
+    grid.x = divUp(src.cols, threads.x);
+    grid.y = divUp(src.rows, threads.y);
 
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar4>();
-        cudaSafeCall( cudaBindTexture2D( 0, tex_meanshift, src.data, desc, src.cols, src.rows, src.step ) );
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar4>();
+    cudaSafeCall( cudaBindTexture2D( 0, tex_meanshift, src.data, desc, src.cols, src.rows, src.step ) );
 
-        meanshiftproc_kernel<<< grid, threads, 0, stream >>>( dstr.data, dstr.step, dstsp.data, dstsp.step, dstr.cols, dstr.rows, sp, sr, maxIter, eps );
-        cudaSafeCall( cudaGetLastError() );
+    meanshiftproc_kernel<<< grid, threads, 0, stream >>>( dstr.data, dstr.step, dstsp.data, dstsp.step, dstr.cols, dstr.rows, sp, sr, maxIter, eps );
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
 
-        //cudaSafeCall( cudaUnbindTexture( tex_meanshift ) );        
-    }
+    //cudaSafeCall( cudaUnbindTexture( tex_meanshift ) );        
+}
 
 /////////////////////////////////// drawColorDisp ///////////////////////////////////////////////
 
-    template <typename T>
-    __device__ unsigned int cvtPixel(T d, int ndisp, float S = 1, float V = 1)
-    {        
-        unsigned int H = ((ndisp-d) * 240)/ndisp;
+template <typename T>
+__device__ unsigned int cvtPixel(T d, int ndisp, float S = 1, float V = 1)
+{        
+    unsigned int H = ((ndisp-d) * 240)/ndisp;
 
-        unsigned int hi = (H/60) % 6;
-        float f = H/60.f - H/60;
-        float p = V * (1 - S);
-        float q = V * (1 - f * S);
-        float t = V * (1 - (1 - f) * S);
+    unsigned int hi = (H/60) % 6;
+    float f = H/60.f - H/60;
+    float p = V * (1 - S);
+    float q = V * (1 - f * S);
+    float t = V * (1 - (1 - f) * S);
 
-        float3 res;
-        
-        if (hi == 0) //R = V,	G = t,	B = p
-        {
-            res.x = p;
-            res.y = t;
-            res.z = V;
-        }
+    float3 res;
+    
+    if (hi == 0) //R = V,	G = t,	B = p
+    {
+        res.x = p;
+        res.y = t;
+        res.z = V;
+    }
 
-        if (hi == 1) // R = q,	G = V,	B = p
-        {
-            res.x = p;
-            res.y = V;
-            res.z = q;
-        }        
+    if (hi == 1) // R = q,	G = V,	B = p
+    {
+        res.x = p;
+        res.y = V;
+        res.z = q;
+    }        
+    
+    if (hi == 2) // R = p,	G = V,	B = t
+    {
+        res.x = t;
+        res.y = V;
+        res.z = p;
+    }
         
-        if (hi == 2) // R = p,	G = V,	B = t
-        {
-            res.x = t;
-            res.y = V;
-            res.z = p;
-        }
-            
-        if (hi == 3) // R = p,	G = q,	B = V
-        {
-            res.x = V;
-            res.y = q;
-            res.z = p;
-        }
-
-        if (hi == 4) // R = t,	G = p,	B = V
-        {
-            res.x = V;
-            res.y = p;
-            res.z = t;
-        }
-
-        if (hi == 5) // R = V,	G = p,	B = q
-        {
-            res.x = q;
-            res.y = p;
-            res.z = V;
-        }
-        const unsigned int b = (unsigned int)(max(0.f, min (res.x, 1.f)) * 255.f);
-        const unsigned int g = (unsigned int)(max(0.f, min (res.y, 1.f)) * 255.f);
-        const unsigned int r = (unsigned int)(max(0.f, min (res.z, 1.f)) * 255.f);
-        const unsigned int a = 255U;
-
-        return (a << 24) + (r << 16) + (g << 8) + b;    
-    } 
-
-    __global__ void drawColorDisp(uchar* disp, size_t disp_step, uchar* out_image, size_t out_step, int width, int height, int ndisp)
+    if (hi == 3) // R = p,	G = q,	B = V
     {
-        const int x = (blockIdx.x * blockDim.x + threadIdx.x) << 2;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        res.x = V;
+        res.y = q;
+        res.z = p;
+    }
 
-        if(x < width && y < height) 
-        {
-            uchar4 d4 = *(uchar4*)(disp + y * disp_step + x);
-
-            uint4 res;
-            res.x = cvtPixel(d4.x, ndisp);
-            res.y = cvtPixel(d4.y, ndisp);
-            res.z = cvtPixel(d4.z, ndisp);
-            res.w = cvtPixel(d4.w, ndisp);
-                    
-            uint4* line = (uint4*)(out_image + y * out_step);
-            line[x >> 2] = res;
-        }
+    if (hi == 4) // R = t,	G = p,	B = V
+    {
+        res.x = V;
+        res.y = p;
+        res.z = t;
     }
 
-    __global__ void drawColorDisp(short* disp, size_t disp_step, uchar* out_image, size_t out_step, int width, int height, int ndisp)
+    if (hi == 5) // R = V,	G = p,	B = q
     {
-        const int x = (blockIdx.x * blockDim.x + threadIdx.x) << 1;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        res.x = q;
+        res.y = p;
+        res.z = V;
+    }
+    const unsigned int b = (unsigned int)(::max(0.f, ::min(res.x, 1.f)) * 255.f);
+    const unsigned int g = (unsigned int)(::max(0.f, ::min(res.y, 1.f)) * 255.f);
+    const unsigned int r = (unsigned int)(::max(0.f, ::min(res.z, 1.f)) * 255.f);
+    const unsigned int a = 255U;
 
-        if(x < width && y < height) 
-        {
-            short2 d2 = *(short2*)(disp + y * disp_step + x);
+    return (a << 24) + (r << 16) + (g << 8) + b;    
+} 
 
-            uint2 res;
-            res.x = cvtPixel(d2.x, ndisp);            
-            res.y = cvtPixel(d2.y, ndisp);
+__global__ void drawColorDisp(uchar* disp, size_t disp_step, uchar* out_image, size_t out_step, int width, int height, int ndisp)
+{
+    const int x = (blockIdx.x * blockDim.x + threadIdx.x) << 2;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-            uint2* line = (uint2*)(out_image + y * out_step);
-            line[x >> 1] = res;
-        }
+    if(x < width && y < height) 
+    {
+        uchar4 d4 = *(uchar4*)(disp + y * disp_step + x);
+
+        uint4 res;
+        res.x = cvtPixel(d4.x, ndisp);
+        res.y = cvtPixel(d4.y, ndisp);
+        res.z = cvtPixel(d4.z, ndisp);
+        res.w = cvtPixel(d4.w, ndisp);
+                
+        uint4* line = (uint4*)(out_image + y * out_step);
+        line[x >> 2] = res;
     }
+}
 
+__global__ void drawColorDisp(short* disp, size_t disp_step, uchar* out_image, size_t out_step, int width, int height, int ndisp)
+{
+    const int x = (blockIdx.x * blockDim.x + threadIdx.x) << 1;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-    void drawColorDisp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int ndisp, const cudaStream_t& stream)
+    if(x < width && y < height) 
     {
-        dim3 threads(16, 16, 1);
-        dim3 grid(1, 1, 1);
-        grid.x = divUp(src.cols, threads.x << 2);
-        grid.y = divUp(src.rows, threads.y);
-         
-        drawColorDisp<<<grid, threads, 0, stream>>>(src.data, src.step, dst.data, dst.step, src.cols, src.rows, ndisp);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() ); 
-    }
+        short2 d2 = *(short2*)(disp + y * disp_step + x);
 
-    void drawColorDisp_gpu(const DevMem2D_<short>& src, const DevMem2Db& dst, int ndisp, const cudaStream_t& stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-        grid.x = divUp(src.cols, threads.x << 1);
-        grid.y = divUp(src.rows, threads.y);
-         
-        drawColorDisp<<<grid, threads, 0, stream>>>(src.data, src.step / sizeof(short), dst.data, dst.step, src.cols, src.rows, ndisp);
-        cudaSafeCall( cudaGetLastError() );
-        
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        uint2 res;
+        res.x = cvtPixel(d2.x, ndisp);            
+        res.y = cvtPixel(d2.y, ndisp);
+
+        uint2* line = (uint2*)(out_image + y * out_step);
+        line[x >> 1] = res;
     }
+}
+
+
+void drawColorDisp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int ndisp, const cudaStream_t& stream)
+{
+    dim3 threads(16, 16, 1);
+    dim3 grid(1, 1, 1);
+    grid.x = divUp(src.cols, threads.x << 2);
+    grid.y = divUp(src.rows, threads.y);
+     
+    drawColorDisp<<<grid, threads, 0, stream>>>(src.data, src.step, dst.data, dst.step, src.cols, src.rows, ndisp);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() ); 
+}
+
+void drawColorDisp_gpu(const DevMem2D_<short>& src, const DevMem2Db& dst, int ndisp, const cudaStream_t& stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+    grid.x = divUp(src.cols, threads.x << 1);
+    grid.y = divUp(src.rows, threads.y);
+     
+    drawColorDisp<<<grid, threads, 0, stream>>>(src.data, src.step / sizeof(short), dst.data, dst.step, src.cols, src.rows, ndisp);
+    cudaSafeCall( cudaGetLastError() );
+    
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 /////////////////////////////////// reprojectImageTo3D ///////////////////////////////////////////////
 
-    __constant__ float cq[16];
+__constant__ float cq[16];
 
-    template <typename T>
-    __global__ void reprojectImageTo3D(const T* disp, size_t disp_step, float* xyzw, size_t xyzw_step, int rows, int cols)
-    {        
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename T>
+__global__ void reprojectImageTo3D(const T* disp, size_t disp_step, float* xyzw, size_t xyzw_step, int rows, int cols)
+{        
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (y < rows && x < cols)
-        {
+    if (y < rows && x < cols)
+    {
 
-            float qx = cq[1] * y + cq[3], qy = cq[5] * y + cq[7];
-            float qz = cq[9] * y + cq[11], qw = cq[13] * y + cq[15];
+        float qx = cq[1] * y + cq[3], qy = cq[5] * y + cq[7];
+        float qz = cq[9] * y + cq[11], qw = cq[13] * y + cq[15];
 
-            qx += x * cq[0]; 
-            qy += x * cq[4];
-            qz += x * cq[8];
-            qw += x * cq[12];
+        qx += x * cq[0]; 
+        qy += x * cq[4];
+        qz += x * cq[8];
+        qw += x * cq[12];
 
-            T d = *(disp + disp_step * y + x);
+        T d = *(disp + disp_step * y + x);
 
-            float iW = 1.f / (qw + cq[14] * d);
-            float4 v;
-            v.x = (qx + cq[2] * d) * iW;
-            v.y = (qy + cq[6] * d) * iW;
-            v.z = (qz + cq[10] * d) * iW;
-            v.w = 1.f;
+        float iW = 1.f / (qw + cq[14] * d);
+        float4 v;
+        v.x = (qx + cq[2] * d) * iW;
+        v.y = (qy + cq[6] * d) * iW;
+        v.z = (qz + cq[10] * d) * iW;
+        v.w = 1.f;
 
-            *(float4*)(xyzw + xyzw_step * y + (x * 4)) = v;
-        }
+        *(float4*)(xyzw + xyzw_step * y + (x * 4)) = v;
     }
+}
 
-    template <typename T>
-    inline void reprojectImageTo3D_caller(const DevMem2D_<T>& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-        grid.x = divUp(disp.cols, threads.x);
-        grid.y = divUp(disp.rows, threads.y);
+template <typename T>
+inline void reprojectImageTo3D_caller(const DevMem2D_<T>& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+    grid.x = divUp(disp.cols, threads.x);
+    grid.y = divUp(disp.rows, threads.y);
 
-        cudaSafeCall( cudaMemcpyToSymbol(cq, q, 16 * sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cq, q, 16 * sizeof(float)) );
 
-        reprojectImageTo3D<<<grid, threads, 0, stream>>>(disp.data, disp.step / sizeof(T), xyzw.data, xyzw.step / sizeof(float), disp.rows, disp.cols);
-        cudaSafeCall( cudaGetLastError() );
+    reprojectImageTo3D<<<grid, threads, 0, stream>>>(disp.data, disp.step / sizeof(T), xyzw.data, xyzw.step / sizeof(float), disp.rows, disp.cols);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    void reprojectImageTo3D_gpu(const DevMem2Db& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream)
-    {
-        reprojectImageTo3D_caller(disp, xyzw, q, stream);
-    }
+void reprojectImageTo3D_gpu(const DevMem2Db& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream)
+{
+    reprojectImageTo3D_caller(disp, xyzw, q, stream);
+}
 
-    void reprojectImageTo3D_gpu(const DevMem2D_<short>& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream)
-    {
-        reprojectImageTo3D_caller(disp, xyzw, q, stream);
-    }
+void reprojectImageTo3D_gpu(const DevMem2D_<short>& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream)
+{
+    reprojectImageTo3D_caller(disp, xyzw, q, stream);
+}
 
 //////////////////////////////////////// Extract Cov Data ////////////////////////////////////////////////
 
-    __global__ void extractCovData_kernel(const int cols, const int rows, const PtrStepf Dx, 
-                                          const PtrStepf Dy, PtrStepf dst)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void extractCovData_kernel(const int cols, const int rows, const PtrStepf Dx, 
+                                      const PtrStepf Dy, PtrStepf dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < cols && y < rows)
-        {            
-            float dx = Dx.ptr(y)[x];
-            float dy = Dy.ptr(y)[x];
+    if (x < cols && y < rows)
+    {            
+        float dx = Dx.ptr(y)[x];
+        float dy = Dy.ptr(y)[x];
 
-            dst.ptr(y)[x] = dx * dx;
-            dst.ptr(y + rows)[x] = dx * dy;
-            dst.ptr(y + (rows << 1))[x] = dy * dy;
-        }
+        dst.ptr(y)[x] = dx * dx;
+        dst.ptr(y + rows)[x] = dx * dy;
+        dst.ptr(y + (rows << 1))[x] = dy * dy;
     }
+}
 
-    void extractCovData_caller(const DevMem2Df Dx, const DevMem2Df Dy, PtrStepf dst, cudaStream_t stream)
-    {
-        dim3 threads(32, 8);
-        dim3 grid(divUp(Dx.cols, threads.x), divUp(Dx.rows, threads.y));
+void extractCovData_caller(const DevMem2Df Dx, const DevMem2Df Dy, PtrStepf dst, cudaStream_t stream)
+{
+    dim3 threads(32, 8);
+    dim3 grid(divUp(Dx.cols, threads.x), divUp(Dx.rows, threads.y));
 
-        extractCovData_kernel<<<grid, threads, 0, stream>>>(Dx.cols, Dx.rows, Dx, Dy, dst);
-        cudaSafeCall( cudaGetLastError() );
+    extractCovData_kernel<<<grid, threads, 0, stream>>>(Dx.cols, Dx.rows, Dx, Dy, dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 /////////////////////////////////////////// Corner Harris /////////////////////////////////////////////////
 
-    texture<float, 2> harrisDxTex;
-    texture<float, 2> harrisDyTex;
+texture<float, 2> harrisDxTex;
+texture<float, 2> harrisDyTex;
 
-    __global__ void cornerHarris_kernel(const int cols, const int rows, const int block_size, const float k,
-                                        PtrStepb dst)
-    {
-        const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void cornerHarris_kernel(const int cols, const int rows, const int block_size, const float k,
+                                    PtrStepb dst)
+{
+    const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < cols && y < rows)
-        {
-            float a = 0.f;
-            float b = 0.f;
-            float c = 0.f;
+    if (x < cols && y < rows)
+    {
+        float a = 0.f;
+        float b = 0.f;
+        float c = 0.f;
 
-            const int ibegin = y - (block_size / 2);
-            const int jbegin = x - (block_size / 2);
-            const int iend = ibegin + block_size;
-            const int jend = jbegin + block_size;
+        const int ibegin = y - (block_size / 2);
+        const int jbegin = x - (block_size / 2);
+        const int iend = ibegin + block_size;
+        const int jend = jbegin + block_size;
 
-            for (int i = ibegin; i < iend; ++i)
+        for (int i = ibegin; i < iend; ++i)
+        {
+            for (int j = jbegin; j < jend; ++j)
             {
-                for (int j = jbegin; j < jend; ++j)
-                {
-                    float dx = tex2D(harrisDxTex, j, i);
-                    float dy = tex2D(harrisDyTex, j, i);
-                    a += dx * dx;
-                    b += dx * dy;
-                    c += dy * dy;
-                }
+                float dx = tex2D(harrisDxTex, j, i);
+                float dy = tex2D(harrisDyTex, j, i);
+                a += dx * dx;
+                b += dx * dy;
+                c += dy * dy;
             }
-
-            ((float*)dst.ptr(y))[x] = a * c - b * b - k * (a + c) * (a + c);
         }
+
+        ((float*)dst.ptr(y))[x] = a * c - b * b - k * (a + c) * (a + c);
     }
+}
 
-    template <typename BR, typename BC>
-    __global__ void cornerHarris_kernel(const int cols, const int rows, const int block_size, const float k,
-                                        PtrStepb dst, BR border_row, BC border_col)
-    {
-        const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename BR, typename BC>
+__global__ void cornerHarris_kernel(const int cols, const int rows, const int block_size, const float k,
+                                    PtrStepb dst, BR border_row, BC border_col)
+{
+    const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < cols && y < rows)
-        {
-            float a = 0.f;
-            float b = 0.f;
-            float c = 0.f;
+    if (x < cols && y < rows)
+    {
+        float a = 0.f;
+        float b = 0.f;
+        float c = 0.f;
 
-            const int ibegin = y - (block_size / 2);
-            const int jbegin = x - (block_size / 2);
-            const int iend = ibegin + block_size;
-            const int jend = jbegin + block_size;
+        const int ibegin = y - (block_size / 2);
+        const int jbegin = x - (block_size / 2);
+        const int iend = ibegin + block_size;
+        const int jend = jbegin + block_size;
 
-            for (int i = ibegin; i < iend; ++i)
+        for (int i = ibegin; i < iend; ++i)
+        {
+            int y = border_col.idx_row(i);
+            for (int j = jbegin; j < jend; ++j)
             {
-                int y = border_col.idx_row(i);
-                for (int j = jbegin; j < jend; ++j)
-                {
-                    int x = border_row.idx_col(j);
-                    float dx = tex2D(harrisDxTex, x, y);
-                    float dy = tex2D(harrisDyTex, x, y);
-                    a += dx * dx;
-                    b += dx * dy;
-                    c += dy * dy;
-                }
+                int x = border_row.idx_col(j);
+                float dx = tex2D(harrisDxTex, x, y);
+                float dy = tex2D(harrisDyTex, x, y);
+                a += dx * dx;
+                b += dx * dy;
+                c += dy * dy;
             }
-
-            ((float*)dst.ptr(y))[x] = a * c - b * b - k * (a + c) * (a + c);
         }
-    }
 
-    void cornerHarris_caller(const int block_size, const float k, const DevMem2Db Dx, const DevMem2Db Dy, DevMem2Db dst, 
-                             int border_type, cudaStream_t stream)
-    {
-        const int rows = Dx.rows;
-        const int cols = Dx.cols;
+        ((float*)dst.ptr(y))[x] = a * c - b * b - k * (a + c) * (a + c);
+    }
+}
 
-        dim3 threads(32, 8);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+void cornerHarris_caller(const int block_size, const float k, const DevMem2Db Dx, const DevMem2Db Dy, DevMem2Db dst, 
+                         int border_type, cudaStream_t stream)
+{
+    const int rows = Dx.rows;
+    const int cols = Dx.cols;
 
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<float>();
-        cudaBindTexture2D(0, harrisDxTex, Dx.data, desc, Dx.cols, Dx.rows, Dx.step);
-        cudaBindTexture2D(0, harrisDyTex, Dy.data, desc, Dy.cols, Dy.rows, Dy.step);
-        harrisDxTex.filterMode = cudaFilterModePoint;
-        harrisDyTex.filterMode = cudaFilterModePoint;
+    dim3 threads(32, 8);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        switch (border_type) 
-        {
-        case BORDER_REFLECT101_GPU:
-            cornerHarris_kernel<<<grid, threads, 0, stream>>>(
-                    cols, rows, block_size, k, dst, BrdRowReflect101<void>(cols), BrdColReflect101<void>(rows));
-            break;
-        case BORDER_REPLICATE_GPU:
-            harrisDxTex.addressMode[0] = cudaAddressModeClamp;
-            harrisDxTex.addressMode[1] = cudaAddressModeClamp;
-            harrisDyTex.addressMode[0] = cudaAddressModeClamp;
-            harrisDyTex.addressMode[1] = cudaAddressModeClamp;
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<float>();
+    cudaBindTexture2D(0, harrisDxTex, Dx.data, desc, Dx.cols, Dx.rows, Dx.step);
+    cudaBindTexture2D(0, harrisDyTex, Dy.data, desc, Dy.cols, Dy.rows, Dy.step);
+    harrisDxTex.filterMode = cudaFilterModePoint;
+    harrisDyTex.filterMode = cudaFilterModePoint;
 
-            cornerHarris_kernel<<<grid, threads, 0, stream>>>(cols, rows, block_size, k, dst);
-            break;
-        }
+    switch (border_type) 
+    {
+    case BORDER_REFLECT101_GPU:
+        cornerHarris_kernel<<<grid, threads, 0, stream>>>(
+                cols, rows, block_size, k, dst, BrdRowReflect101<void>(cols), BrdColReflect101<void>(rows));
+        break;
+    case BORDER_REPLICATE_GPU:
+        harrisDxTex.addressMode[0] = cudaAddressModeClamp;
+        harrisDxTex.addressMode[1] = cudaAddressModeClamp;
+        harrisDyTex.addressMode[0] = cudaAddressModeClamp;
+        harrisDyTex.addressMode[1] = cudaAddressModeClamp;
+
+        cornerHarris_kernel<<<grid, threads, 0, stream>>>(cols, rows, block_size, k, dst);
+        break;
+    }
 
-        cudaSafeCall( cudaGetLastError() );
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
 
-        //cudaSafeCall(cudaUnbindTexture(harrisDxTex));
-        //cudaSafeCall(cudaUnbindTexture(harrisDyTex));
-    }
+    //cudaSafeCall(cudaUnbindTexture(harrisDxTex));
+    //cudaSafeCall(cudaUnbindTexture(harrisDyTex));
+}
 
 /////////////////////////////////////////// Corner Min Eigen Val /////////////////////////////////////////////////
 
-    texture<float, 2> minEigenValDxTex;
-    texture<float, 2> minEigenValDyTex;
+texture<float, 2> minEigenValDxTex;
+texture<float, 2> minEigenValDyTex;
 
-    __global__ void cornerMinEigenVal_kernel(const int cols, const int rows, const int block_size, 
-                                             PtrStepb dst)
-    {
-        const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void cornerMinEigenVal_kernel(const int cols, const int rows, const int block_size, 
+                                         PtrStepb dst)
+{
+    const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < cols && y < rows)
-        {
-            float a = 0.f;
-            float b = 0.f;
-            float c = 0.f;
+    if (x < cols && y < rows)
+    {
+        float a = 0.f;
+        float b = 0.f;
+        float c = 0.f;
 
-            const int ibegin = y - (block_size / 2);
-            const int jbegin = x - (block_size / 2);
-            const int iend = ibegin + block_size;
-            const int jend = jbegin + block_size;
+        const int ibegin = y - (block_size / 2);
+        const int jbegin = x - (block_size / 2);
+        const int iend = ibegin + block_size;
+        const int jend = jbegin + block_size;
 
-            for (int i = ibegin; i < iend; ++i)
+        for (int i = ibegin; i < iend; ++i)
+        {
+            for (int j = jbegin; j < jend; ++j)
             {
-                for (int j = jbegin; j < jend; ++j)
-                {
-                    float dx = tex2D(minEigenValDxTex, j, i);
-                    float dy = tex2D(minEigenValDyTex, j, i);
-                    a += dx * dx;
-                    b += dx * dy;
-                    c += dy * dy;
-                }
+                float dx = tex2D(minEigenValDxTex, j, i);
+                float dy = tex2D(minEigenValDyTex, j, i);
+                a += dx * dx;
+                b += dx * dy;
+                c += dy * dy;
             }
-
-            a *= 0.5f;
-            c *= 0.5f;
-            ((float*)dst.ptr(y))[x] = (a + c) - sqrtf((a - c) * (a - c) + b * b);
         }
+
+        a *= 0.5f;
+        c *= 0.5f;
+        ((float*)dst.ptr(y))[x] = (a + c) - sqrtf((a - c) * (a - c) + b * b);
     }
+}
 
 
-    template <typename BR, typename BC>
-    __global__ void cornerMinEigenVal_kernel(const int cols, const int rows, const int block_size, 
-                                             PtrStepb dst, BR border_row, BC border_col)
-    {
-        const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename BR, typename BC>
+__global__ void cornerMinEigenVal_kernel(const int cols, const int rows, const int block_size, 
+                                         PtrStepb dst, BR border_row, BC border_col)
+{
+    const unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < cols && y < rows)
-        {
-            float a = 0.f;
-            float b = 0.f;
-            float c = 0.f;
+    if (x < cols && y < rows)
+    {
+        float a = 0.f;
+        float b = 0.f;
+        float c = 0.f;
 
-            const int ibegin = y - (block_size / 2);
-            const int jbegin = x - (block_size / 2);
-            const int iend = ibegin + block_size;
-            const int jend = jbegin + block_size;
+        const int ibegin = y - (block_size / 2);
+        const int jbegin = x - (block_size / 2);
+        const int iend = ibegin + block_size;
+        const int jend = jbegin + block_size;
 
-            for (int i = ibegin; i < iend; ++i)
+        for (int i = ibegin; i < iend; ++i)
+        {
+            int y = border_col.idx_row(i);
+            for (int j = jbegin; j < jend; ++j)
             {
-                int y = border_col.idx_row(i);
-                for (int j = jbegin; j < jend; ++j)
-                {
-                    int x = border_row.idx_col(j);
-                    float dx = tex2D(minEigenValDxTex, x, y);
-                    float dy = tex2D(minEigenValDyTex, x, y);
-                    a += dx * dx;
-                    b += dx * dy;
-                    c += dy * dy;
-                }
+                int x = border_row.idx_col(j);
+                float dx = tex2D(minEigenValDxTex, x, y);
+                float dy = tex2D(minEigenValDyTex, x, y);
+                a += dx * dx;
+                b += dx * dy;
+                c += dy * dy;
             }
-
-            a *= 0.5f;
-            c *= 0.5f;
-            ((float*)dst.ptr(y))[x] = (a + c) - sqrtf((a - c) * (a - c) + b * b);
         }
-    }
 
-    void cornerMinEigenVal_caller(const int block_size, const DevMem2Db Dx, const DevMem2Db Dy, DevMem2Db dst,
-                                  int border_type, cudaStream_t stream)
-    {
-        const int rows = Dx.rows;
-        const int cols = Dx.cols;
+        a *= 0.5f;
+        c *= 0.5f;
+        ((float*)dst.ptr(y))[x] = (a + c) - sqrtf((a - c) * (a - c) + b * b);
+    }
+}
 
-        dim3 threads(32, 8);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+void cornerMinEigenVal_caller(const int block_size, const DevMem2Db Dx, const DevMem2Db Dy, DevMem2Db dst,
+                              int border_type, cudaStream_t stream)
+{
+    const int rows = Dx.rows;
+    const int cols = Dx.cols;
 
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<float>();
-        cudaBindTexture2D(0, minEigenValDxTex, Dx.data, desc, Dx.cols, Dx.rows, Dx.step);
-        cudaBindTexture2D(0, minEigenValDyTex, Dy.data, desc, Dy.cols, Dy.rows, Dy.step);
-        minEigenValDxTex.filterMode = cudaFilterModePoint;
-        minEigenValDyTex.filterMode = cudaFilterModePoint;
+    dim3 threads(32, 8);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        switch (border_type)
-        {
-        case BORDER_REFLECT101_GPU:
-            cornerMinEigenVal_kernel<<<grid, threads, 0, stream>>>(
-                    cols, rows, block_size, dst, BrdRowReflect101<void>(cols), BrdColReflect101<void>(rows));
-            break;
-        case BORDER_REPLICATE_GPU:
-            minEigenValDxTex.addressMode[0] = cudaAddressModeClamp;
-            minEigenValDxTex.addressMode[1] = cudaAddressModeClamp;
-            minEigenValDyTex.addressMode[0] = cudaAddressModeClamp;
-            minEigenValDyTex.addressMode[1] = cudaAddressModeClamp;
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<float>();
+    cudaBindTexture2D(0, minEigenValDxTex, Dx.data, desc, Dx.cols, Dx.rows, Dx.step);
+    cudaBindTexture2D(0, minEigenValDyTex, Dy.data, desc, Dy.cols, Dy.rows, Dy.step);
+    minEigenValDxTex.filterMode = cudaFilterModePoint;
+    minEigenValDyTex.filterMode = cudaFilterModePoint;
 
-            cornerMinEigenVal_kernel<<<grid, threads, 0, stream>>>(cols, rows, block_size, dst);
-            break;
-        }
+    switch (border_type)
+    {
+    case BORDER_REFLECT101_GPU:
+        cornerMinEigenVal_kernel<<<grid, threads, 0, stream>>>(
+                cols, rows, block_size, dst, BrdRowReflect101<void>(cols), BrdColReflect101<void>(rows));
+        break;
+    case BORDER_REPLICATE_GPU:
+        minEigenValDxTex.addressMode[0] = cudaAddressModeClamp;
+        minEigenValDxTex.addressMode[1] = cudaAddressModeClamp;
+        minEigenValDyTex.addressMode[0] = cudaAddressModeClamp;
+        minEigenValDyTex.addressMode[1] = cudaAddressModeClamp;
+
+        cornerMinEigenVal_kernel<<<grid, threads, 0, stream>>>(cols, rows, block_size, dst);
+        break;
+    }
 
-        cudaSafeCall( cudaGetLastError() );
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
 
-        //cudaSafeCall(cudaUnbindTexture(minEigenValDxTex));
-        //cudaSafeCall(cudaUnbindTexture(minEigenValDyTex));
-    }
+    //cudaSafeCall(cudaUnbindTexture(minEigenValDxTex));
+    //cudaSafeCall(cudaUnbindTexture(minEigenValDyTex));
+}
 
 ////////////////////////////// Column Sum //////////////////////////////////////
 
-    __global__ void column_sumKernel_32F(int cols, int rows, const PtrStepb src, const PtrStepb dst)
+__global__ void column_sumKernel_32F(int cols, int rows, const PtrStepb src, const PtrStepb dst)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+    if (x < cols)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const unsigned char* src_data = src.data + x * sizeof(float);
+        unsigned char* dst_data = dst.data + x * sizeof(float);
 
-        if (x < cols)
+        float sum = 0.f;
+        for (int y = 0; y < rows; ++y)
         {
-            const unsigned char* src_data = src.data + x * sizeof(float);
-            unsigned char* dst_data = dst.data + x * sizeof(float);
-
-            float sum = 0.f;
-            for (int y = 0; y < rows; ++y)
-            {
-                sum += *(const float*)src_data;
-                *(float*)dst_data = sum;
-                src_data += src.step;
-                dst_data += dst.step;
-            }
+            sum += *(const float*)src_data;
+            *(float*)dst_data = sum;
+            src_data += src.step;
+            dst_data += dst.step;
         }
     }
+}
 
 
-    void columnSum_32F(const DevMem2Db src, const DevMem2Db dst)
-    {
-        dim3 threads(256);
-        dim3 grid(divUp(src.cols, threads.x));
+void columnSum_32F(const DevMem2Db src, const DevMem2Db dst)
+{
+    dim3 threads(256);
+    dim3 grid(divUp(src.cols, threads.x));
 
-        column_sumKernel_32F<<<grid, threads>>>(src.cols, src.rows, src, dst);
-        cudaSafeCall( cudaGetLastError() );
+    column_sumKernel_32F<<<grid, threads>>>(src.cols, src.rows, src, dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // mulSpectrums
+//////////////////////////////////////////////////////////////////////////
+// mulSpectrums
 
-    __global__ void mulSpectrumsKernel(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;    
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;    
+__global__ void mulSpectrumsKernel(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;    
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;    
 
-        if (x < c.cols && y < c.rows) 
-        {
-            c.ptr(y)[x] = cuCmulf(a.ptr(y)[x], b.ptr(y)[x]);
-        }
+    if (x < c.cols && y < c.rows) 
+    {
+        c.ptr(y)[x] = cuCmulf(a.ptr(y)[x], b.ptr(y)[x]);
     }
+}
 
 
-    void mulSpectrums(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c, cudaStream_t stream)
-    {
-        dim3 threads(256);
-        dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
+void mulSpectrums(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c, cudaStream_t stream)
+{
+    dim3 threads(256);
+    dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
 
-        mulSpectrumsKernel<<<grid, threads, 0, stream>>>(a, b, c);
-        cudaSafeCall( cudaGetLastError() );
+    mulSpectrumsKernel<<<grid, threads, 0, stream>>>(a, b, c);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // mulSpectrums_CONJ
+//////////////////////////////////////////////////////////////////////////
+// mulSpectrums_CONJ
 
-    __global__ void mulSpectrumsKernel_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;    
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;    
+__global__ void mulSpectrumsKernel_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;    
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;    
 
-        if (x < c.cols && y < c.rows) 
-        {
-            c.ptr(y)[x] = cuCmulf(a.ptr(y)[x], cuConjf(b.ptr(y)[x]));
-        }
+    if (x < c.cols && y < c.rows) 
+    {
+        c.ptr(y)[x] = cuCmulf(a.ptr(y)[x], cuConjf(b.ptr(y)[x]));
     }
+}
 
 
-    void mulSpectrums_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c, cudaStream_t stream)
-    {
-        dim3 threads(256);
-        dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
+void mulSpectrums_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c, cudaStream_t stream)
+{
+    dim3 threads(256);
+    dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
 
-        mulSpectrumsKernel_CONJ<<<grid, threads, 0, stream>>>(a, b, c);
-        cudaSafeCall( cudaGetLastError() );
+    mulSpectrumsKernel_CONJ<<<grid, threads, 0, stream>>>(a, b, c);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // mulAndScaleSpectrums
+//////////////////////////////////////////////////////////////////////////
+// mulAndScaleSpectrums
 
-    __global__ void mulAndScaleSpectrumsKernel(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void mulAndScaleSpectrumsKernel(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < c.cols && y < c.rows) 
-        {
-            cufftComplex v = cuCmulf(a.ptr(y)[x], b.ptr(y)[x]);
-            c.ptr(y)[x] = make_cuFloatComplex(cuCrealf(v) * scale, cuCimagf(v) * scale);
-        }
+    if (x < c.cols && y < c.rows) 
+    {
+        cufftComplex v = cuCmulf(a.ptr(y)[x], b.ptr(y)[x]);
+        c.ptr(y)[x] = make_cuFloatComplex(cuCrealf(v) * scale, cuCimagf(v) * scale);
     }
+}
 
 
-    void mulAndScaleSpectrums(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c, cudaStream_t stream)
-    {
-        dim3 threads(256);
-        dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
+void mulAndScaleSpectrums(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c, cudaStream_t stream)
+{
+    dim3 threads(256);
+    dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
 
-        mulAndScaleSpectrumsKernel<<<grid, threads, 0, stream>>>(a, b, scale, c);
-        cudaSafeCall( cudaGetLastError() );
+    mulAndScaleSpectrumsKernel<<<grid, threads, 0, stream>>>(a, b, scale, c);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // mulAndScaleSpectrums_CONJ
+//////////////////////////////////////////////////////////////////////////
+// mulAndScaleSpectrums_CONJ
 
-    __global__ void mulAndScaleSpectrumsKernel_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+__global__ void mulAndScaleSpectrumsKernel_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < c.cols && y < c.rows) 
-        {
-            cufftComplex v = cuCmulf(a.ptr(y)[x], cuConjf(b.ptr(y)[x]));
-            c.ptr(y)[x] = make_cuFloatComplex(cuCrealf(v) * scale, cuCimagf(v) * scale);
-        }
+    if (x < c.cols && y < c.rows) 
+    {
+        cufftComplex v = cuCmulf(a.ptr(y)[x], cuConjf(b.ptr(y)[x]));
+        c.ptr(y)[x] = make_cuFloatComplex(cuCrealf(v) * scale, cuCimagf(v) * scale);
     }
+}
 
 
-    void mulAndScaleSpectrums_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c, cudaStream_t stream)
-    {
-        dim3 threads(256);
-        dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
+void mulAndScaleSpectrums_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c, cudaStream_t stream)
+{
+    dim3 threads(256);
+    dim3 grid(divUp(c.cols, threads.x), divUp(c.rows, threads.y));
 
-        mulAndScaleSpectrumsKernel_CONJ<<<grid, threads, 0, stream>>>(a, b, scale, c);
-        cudaSafeCall( cudaGetLastError() );
+    mulAndScaleSpectrumsKernel_CONJ<<<grid, threads, 0, stream>>>(a, b, scale, c);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }    
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}    
 
-    //////////////////////////////////////////////////////////////////////////
-    // buildWarpMaps
+//////////////////////////////////////////////////////////////////////////
+// buildWarpMaps
 
-    // TODO use intrinsics like __sinf and so on
+// TODO use intrinsics like __sinf and so on
 
-    namespace build_warp_maps
-    {
+namespace build_warp_maps
+{
 
-        __constant__ float ck_rinv[9];
-        __constant__ float cr_kinv[9];
-        __constant__ float ct[3];
-        __constant__ float cscale;
-    }
+    __constant__ float ck_rinv[9];
+    __constant__ float cr_kinv[9];
+    __constant__ float ct[3];
+    __constant__ float cscale;
+}
 
 
-    class PlaneMapper
+class PlaneMapper
+{
+public:
+    static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
     {
-    public:
-        static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
-        {
-            using namespace build_warp_maps;
+        using namespace build_warp_maps;
 
-            float x_ = u / cscale - ct[0];
-            float y_ = v / cscale - ct[1];
+        float x_ = u / cscale - ct[0];
+        float y_ = v / cscale - ct[1];
 
-            float z;
-            x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * (1 - ct[2]);
-            y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * (1 - ct[2]);
-            z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * (1 - ct[2]);
+        float z;
+        x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * (1 - ct[2]);
+        y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * (1 - ct[2]);
+        z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * (1 - ct[2]);
 
-            x /= z;
-            y /= z;
-        }
-    };
+        x /= z;
+        y /= z;
+    }
+};
 
 
-    class CylindricalMapper
+class CylindricalMapper
+{
+public:
+    static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
     {
-    public:
-        static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
-        {
-            using namespace build_warp_maps;
+        using namespace build_warp_maps;
 
-            u /= cscale;
-            float x_ = sinf(u);
-            float y_ = v / cscale;
-            float z_ = cosf(u);
+        u /= cscale;
+        float x_ = ::sinf(u);
+        float y_ = v / cscale;
+        float z_ = ::cosf(u);
 
-            float z;
-            x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * z_;
-            y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * z_;
-            z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * z_;
+        float z;
+        x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * z_;
+        y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * z_;
+        z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * z_;
 
-            if (z > 0) { x /= z; y /= z; }
-            else x = y = -1;
-        }
-    };
+        if (z > 0) { x /= z; y /= z; }
+        else x = y = -1;
+    }
+};
 
 
-    class SphericalMapper
+class SphericalMapper
+{
+public:
+    static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
     {
-    public:
-        static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
-        {
-            using namespace build_warp_maps;
+        using namespace build_warp_maps;
 
-            v /= cscale;
-            u /= cscale;
+        v /= cscale;
+        u /= cscale;
 
-            float sinv = sinf(v);
-            float x_ = sinv * sinf(u);
-            float y_ = -cosf(v);
-            float z_ = sinv * cosf(u);
+        float sinv = ::sinf(v);
+        float x_ = sinv * ::sinf(u);
+        float y_ = -::cosf(v);
+        float z_ = sinv * ::cosf(u);
 
-            float z;
-            x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * z_;
-            y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * z_;
-            z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * z_;
+        float z;
+        x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * z_;
+        y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * z_;
+        z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * z_;
 
-            if (z > 0) { x /= z; y /= z; }
-            else x = y = -1;
-        }
-    };
+        if (z > 0) { x /= z; y /= z; }
+        else x = y = -1;
+    }
+};
 
 
-    template <typename Mapper>
-    __global__ void buildWarpMapsKernel(int tl_u, int tl_v, int cols, int rows,
-                                        PtrStepf map_x, PtrStepf map_y)
+template <typename Mapper>
+__global__ void buildWarpMapsKernel(int tl_u, int tl_v, int cols, int rows,
+                                    PtrStepf map_x, PtrStepf map_y)
+{
+    int du = blockIdx.x * blockDim.x + threadIdx.x;
+    int dv = blockIdx.y * blockDim.y + threadIdx.y;
+    if (du < cols && dv < rows)
     {
-        int du = blockIdx.x * blockDim.x + threadIdx.x;
-        int dv = blockIdx.y * blockDim.y + threadIdx.y;
-        if (du < cols && dv < rows)
-        {
-            float u = tl_u + du;
-            float v = tl_v + dv;
-            float x, y;
-            Mapper::mapBackward(u, v, x, y);
-            map_x.ptr(dv)[du] = x;
-            map_y.ptr(dv)[du] = y;
-        }
+        float u = tl_u + du;
+        float v = tl_v + dv;
+        float x, y;
+        Mapper::mapBackward(u, v, x, y);
+        map_x.ptr(dv)[du] = x;
+        map_y.ptr(dv)[du] = y;
     }
+}
 
 
-    void buildWarpPlaneMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
-                            const float k_rinv[9], const float r_kinv[9], const float t[3], 
-                            float scale, cudaStream_t stream)
-    {
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ck_rinv, k_rinv, 9*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr_kinv, r_kinv, 9*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ct, t, 3*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cscale, &scale, sizeof(float)));
+void buildWarpPlaneMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                        const float k_rinv[9], const float r_kinv[9], const float t[3], 
+                        float scale, cudaStream_t stream)
+{
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ck_rinv, k_rinv, 9*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr_kinv, r_kinv, 9*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ct, t, 3*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cscale, &scale, sizeof(float)));
 
-        int cols = map_x.cols;
-        int rows = map_x.rows;
+    int cols = map_x.cols;
+    int rows = map_x.rows;
 
-        dim3 threads(32, 8);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+    dim3 threads(32, 8);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        buildWarpMapsKernel<PlaneMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
-        cudaSafeCall(cudaGetLastError());
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+    buildWarpMapsKernel<PlaneMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
+    cudaSafeCall(cudaGetLastError());
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
 
-    void buildWarpCylindricalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
-                                  const float k_rinv[9], const float r_kinv[9], float scale,
-                                  cudaStream_t stream)
-    {
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ck_rinv, k_rinv, 9*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr_kinv, r_kinv, 9*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cscale, &scale, sizeof(float)));
+void buildWarpCylindricalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                              const float k_rinv[9], const float r_kinv[9], float scale,
+                              cudaStream_t stream)
+{
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ck_rinv, k_rinv, 9*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr_kinv, r_kinv, 9*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cscale, &scale, sizeof(float)));
 
-        int cols = map_x.cols;
-        int rows = map_x.rows;
+    int cols = map_x.cols;
+    int rows = map_x.rows;
 
-        dim3 threads(32, 8);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+    dim3 threads(32, 8);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        buildWarpMapsKernel<CylindricalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
-        cudaSafeCall(cudaGetLastError());
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+    buildWarpMapsKernel<CylindricalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
+    cudaSafeCall(cudaGetLastError());
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
 
-    void buildWarpSphericalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
-                                const float k_rinv[9], const float r_kinv[9], float scale,
-                                cudaStream_t stream)
-    {
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ck_rinv, k_rinv, 9*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr_kinv, r_kinv, 9*sizeof(float)));
-        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cscale, &scale, sizeof(float)));
+void buildWarpSphericalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                            const float k_rinv[9], const float r_kinv[9], float scale,
+                            cudaStream_t stream)
+{
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::ck_rinv, k_rinv, 9*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr_kinv, r_kinv, 9*sizeof(float)));
+    cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cscale, &scale, sizeof(float)));
 
-        int cols = map_x.cols;
-        int rows = map_x.rows;
+    int cols = map_x.cols;
+    int rows = map_x.rows;
 
-        dim3 threads(32, 8);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+    dim3 threads(32, 8);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        buildWarpMapsKernel<SphericalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
-        cudaSafeCall(cudaGetLastError());
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+    buildWarpMapsKernel<SphericalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
+    cudaSafeCall(cudaGetLastError());
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // convolve
+//////////////////////////////////////////////////////////////////////////
+// convolve
 
-    #define CONVOLVE_MAX_KERNEL_SIZE 17
+#define CONVOLVE_MAX_KERNEL_SIZE 17
 
-    __constant__ float c_convolveKernel[CONVOLVE_MAX_KERNEL_SIZE * CONVOLVE_MAX_KERNEL_SIZE];
+__constant__ float c_convolveKernel[CONVOLVE_MAX_KERNEL_SIZE * CONVOLVE_MAX_KERNEL_SIZE];
 
-    __global__ void convolve(const DevMem2Df src, PtrStepf dst, int kWidth, int kHeight)
+__global__ void convolve(const DevMem2Df src, PtrStepf dst, int kWidth, int kHeight)
+{
+    __shared__ float smem[16 + 2 * 8][16 + 2 * 8];
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    // x | x 0 | 0
+    // -----------
+    // x | x 0 | 0
+    // 0 | 0 0 | 0
+    // -----------
+    // 0 | 0 0 | 0
+    smem[threadIdx.y][threadIdx.x] = src.ptr(::min(::max(y - 8, 0), src.rows - 1))[::min(::max(x - 8, 0), src.cols - 1)];
+
+    // 0 | 0 x | x
+    // -----------
+    // 0 | 0 x | x
+    // 0 | 0 0 | 0
+    // -----------
+    // 0 | 0 0 | 0
+    smem[threadIdx.y][threadIdx.x + 16] = src.ptr(::min(::max(y - 8, 0), src.rows - 1))[::min(x + 8, src.cols - 1)];
+
+    // 0 | 0 0 | 0
+    // -----------
+    // 0 | 0 0 | 0
+    // x | x 0 | 0
+    // -----------
+    // x | x 0 | 0
+    smem[threadIdx.y + 16][threadIdx.x] = src.ptr(::min(y + 8, src.rows - 1))[::min(::max(x - 8, 0), src.cols - 1)];
+
+    // 0 | 0 0 | 0
+    // -----------
+    // 0 | 0 0 | 0
+    // 0 | 0 x | x
+    // -----------
+    // 0 | 0 x | x
+    smem[threadIdx.y + 16][threadIdx.x + 16] = src.ptr(::min(y + 8, src.rows - 1))[::min(x + 8, src.cols - 1)];
+
+    __syncthreads();
+
+    if (x < src.cols && y < src.rows)
     {
-        __shared__ float smem[16 + 2 * 8][16 + 2 * 8];
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        // x | x 0 | 0
-        // -----------
-        // x | x 0 | 0
-        // 0 | 0 0 | 0
-        // -----------
-        // 0 | 0 0 | 0
-        smem[threadIdx.y][threadIdx.x] = src.ptr(min(max(y - 8, 0), src.rows - 1))[min(max(x - 8, 0), src.cols - 1)];
-
-        // 0 | 0 x | x
-        // -----------
-        // 0 | 0 x | x
-        // 0 | 0 0 | 0
-        // -----------
-        // 0 | 0 0 | 0
-        smem[threadIdx.y][threadIdx.x + 16] = src.ptr(min(max(y - 8, 0), src.rows - 1))[min(x + 8, src.cols - 1)];
-
-        // 0 | 0 0 | 0
-        // -----------
-        // 0 | 0 0 | 0
-        // x | x 0 | 0
-        // -----------
-        // x | x 0 | 0
-        smem[threadIdx.y + 16][threadIdx.x] = src.ptr(min(y + 8, src.rows - 1))[min(max(x - 8, 0), src.cols - 1)];
-
-        // 0 | 0 0 | 0
-        // -----------
-        // 0 | 0 0 | 0
-        // 0 | 0 x | x
-        // -----------
-        // 0 | 0 x | x
-        smem[threadIdx.y + 16][threadIdx.x + 16] = src.ptr(min(y + 8, src.rows - 1))[min(x + 8, src.cols - 1)];
-
-        __syncthreads();
-
-        if (x < src.cols && y < src.rows)
-        {
-            float res = 0;
+        float res = 0;
 
-            for (int i = 0; i < kHeight; ++i)
+        for (int i = 0; i < kHeight; ++i)
+        {
+            for (int j = 0; j < kWidth; ++j)
             {
-                for (int j = 0; j < kWidth; ++j)
-                {
-                    res += smem[threadIdx.y + 8 - kHeight / 2 + i][threadIdx.x + 8 - kWidth / 2 + j] * c_convolveKernel[i * kWidth + j];
-                }
+                res += smem[threadIdx.y + 8 - kHeight / 2 + i][threadIdx.x + 8 - kWidth / 2 + j] * c_convolveKernel[i * kWidth + j];
             }
-
-            dst.ptr(y)[x] = res;
         }
-    }
-
-    void convolve_gpu(const DevMem2Df& src, const PtrStepf& dst, int kWidth, int kHeight, float* kernel, cudaStream_t stream)
-    {
-        cudaSafeCall(cudaMemcpyToSymbol(c_convolveKernel, kernel, kWidth * kHeight * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
 
-        const dim3 block(16, 16);
-        const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+        dst.ptr(y)[x] = res;
+    }
+}
 
-        convolve<<<grid, block, 0, stream>>>(src, dst, kWidth, kHeight);
-        cudaSafeCall(cudaGetLastError());
+void convolve_gpu(const DevMem2Df& src, const PtrStepf& dst, int kWidth, int kHeight, float* kernel, cudaStream_t stream)
+{
+    cudaSafeCall(cudaMemcpyToSymbol(c_convolveKernel, kernel, kWidth * kHeight * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
 
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+    const dim3 block(16, 16);
+    const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
 
+    convolve<<<grid, block, 0, stream>>>(src, dst, kWidth, kHeight);
+    cudaSafeCall(cudaGetLastError());
 
-}}}
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
+} // namespace imgproc
 
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/internal_shared.hpp b/modules/gpu/src/cuda/internal_shared.hpp
index 1d13735f99c2a3c0f3d162df344a39d3b1785334..7c27675becb3c85d20b76dc0885753508b3a569d 100644
--- a/modules/gpu/src/cuda/internal_shared.hpp
+++ b/modules/gpu/src/cuda/internal_shared.hpp
@@ -43,11 +43,15 @@
 #ifndef __OPENCV_internal_shared_HPP__
 #define __OPENCV_internal_shared_HPP__
 
+#include <cuda_runtime.h>
+#include <npp.h>
+#include "NPP_staging.hpp"
 #include "opencv2/gpu/devmem2d.hpp"
 #include "safe_call.hpp"
-#include "cuda_runtime.h"
-#include "npp.h"
-#include "NPP_staging.hpp"
+
+#ifndef CV_PI
+#define CV_PI   3.1415926535897932384626433832795f
+#endif
 
 #ifndef CV_PI_F
   #ifndef CV_PI
@@ -57,146 +61,158 @@
   #endif
 #endif
 
-namespace cv
+#define BEGIN_OPENCV_DEVICE_NAMESPACE namespace cv { namespace gpu { namespace device { 
+#define END_OPENCV_DEVICE_NAMESPACE   }}}
+#define OPENCV_DEVICE_NAMESPACE       ::cv::gpu::device
+#define OPENCV_DEVICE_NAMESPACE_      ::cv::gpu::device:: 
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef signed char schar;
+typedef unsigned int uint;
+
+template<class T> static inline void bindTexture(const textureReference* tex, const DevMem2D_<T>& img)
 {
-    namespace gpu
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+    cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+}
+
+END_OPENCV_DEVICE_NAMESPACE
+
+namespace cv { namespace gpu 
+{
+    enum 
     {
-        typedef unsigned char uchar;
-        typedef signed char schar;
-        typedef unsigned short ushort;
-        typedef unsigned int uint;       
+        BORDER_REFLECT101_GPU = 0,
+        BORDER_REPLICATE_GPU,
+        BORDER_CONSTANT_GPU,
+        BORDER_REFLECT_GPU,
+        BORDER_WRAP_GPU
+    };
+            
+    // Converts CPU border extrapolation mode into GPU internal analogue.
+    // Returns true if the GPU analogue exists, false otherwise.
+    bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
+
+    static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
 
-        enum 
+    /*template<class T> static inline void uploadConstant(const char* name, const T& value) 
+    { 
+        cudaSafeCall( cudaMemcpyToSymbol(name, &value, sizeof(T)) ); 
+    }
+
+    template<class T> static inline void uploadConstant(const char* name, const T& value, cudaStream_t stream) 
+    {
+        cudaSafeCall( cudaMemcpyToSymbolAsync(name, &value, sizeof(T), 0, cudaMemcpyHostToDevice, stream) ); 
+    }   */     
+
+    //template<class T> static inline void bindTexture(const char* name, const DevMem2D_<T>& img)
+    //{            
+    //    //!!!! const_cast is disabled!
+    //    //!!!! Please use constructor of 'class texture'  instead.
+    //
+    //    //textureReference* tex; 
+    //    //cudaSafeCall( cudaGetTextureReference((const textureReference**)&tex, name) ); 
+    //    //tex->normalized = normalized;
+    //    //tex->filterMode = filterMode;
+    //    //tex->addressMode[0] = addrMode;
+    //    //tex->addressMode[1] = addrMode;
+    //    
+    //    const textureReference* tex; 
+    //    cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
+    //
+    //    cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+    //    cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+    //}
+
+    //static inline void unbindTexture(const char *name)
+    //{
+    //    const textureReference* tex; 
+    //    cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
+    //    cudaSafeCall( cudaUnbindTexture(tex) );
+    //}
+
+    
+
+    //class TextureBinder
+    //{
+    //public:
+    //    TextureBinder() : tex_(0) {}
+    //    template <typename T> TextureBinder(const textureReference* tex, const DevMem2D_<T>& img) : tex_(0)
+    //    {
+    //        bind(tex, img);
+    //    }
+    //    template <typename T> TextureBinder(const char* tex_name, const DevMem2D_<T>& img) : tex_(0)
+    //    {
+    //        bind(tex_name, img);
+    //    }
+    //    ~TextureBinder() { unbind(); }
+    //
+    //    template <typename T> void bind(const textureReference* tex, const DevMem2D_<T>& img)
+    //    {
+    //        unbind();
+    //
+    //        cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+    //        cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+    //
+    //        tex_ = tex;
+    //    }
+    //    template <typename T> void bind(const char* tex_name, const DevMem2D_<T>& img)
+    //    {
+    //        const textureReference* tex; 
+    //        cudaSafeCall( cudaGetTextureReference(&tex, tex_name) ); 
+    //        bind(tex, img);
+    //    }
+    //
+    //    void unbind()
+    //    {
+    //        if (tex_)
+    //        {
+    //            cudaUnbindTexture(tex_);
+    //            tex_ = 0;
+    //        }
+    //    }
+    //
+    //private:
+    //    const textureReference* tex_;
+    //};
+
+    class NppStreamHandler
+    {
+    public:
+        inline explicit NppStreamHandler(cudaStream_t newStream = 0)
         {
-            BORDER_REFLECT101_GPU = 0,
-            BORDER_REPLICATE_GPU,
-            BORDER_CONSTANT_GPU,
-            BORDER_REFLECT_GPU,
-            BORDER_WRAP_GPU
-        };
-                
-        // Converts CPU border extrapolation mode into GPU internal analogue.
-        // Returns true if the GPU analogue exists, false otherwise.
-        bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
-
-        static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
-
-        template<class T> static inline void uploadConstant(const char* name, const T& value) 
-        { 
-            cudaSafeCall( cudaMemcpyToSymbol(name, &value, sizeof(T)) ); 
+            oldStream = nppGetStream();
+            nppSetStream(newStream);
         }
 
-        template<class T> static inline void uploadConstant(const char* name, const T& value, cudaStream_t stream) 
+        inline ~NppStreamHandler()
         {
-            cudaSafeCall( cudaMemcpyToSymbolAsync(name, &value, sizeof(T), 0, cudaMemcpyHostToDevice, stream) ); 
-        }        
-
-        template<class T> static inline void bindTexture(const char* name, const DevMem2D_<T>& img/*, bool normalized = false,
-            enum cudaTextureFilterMode filterMode = cudaFilterModePoint, enum cudaTextureAddressMode addrMode = cudaAddressModeClamp*/)
-        {            
-            //!!!! const_cast is disabled!
-            //!!!! Please use constructor of 'class texture'  instead.
-
-            //textureReference* tex; 
-            //cudaSafeCall( cudaGetTextureReference((const textureReference**)&tex, name) ); 
-            //tex->normalized = normalized;
-            //tex->filterMode = filterMode;
-            //tex->addressMode[0] = addrMode;
-            //tex->addressMode[1] = addrMode;
-            
-            const textureReference* tex; 
-            cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
-
-            cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
-            cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+            nppSetStream(oldStream);
         }
 
-        static inline void unbindTexture(const char *name)
+    private:
+        cudaStream_t oldStream;
+    };
+
+    class NppStStreamHandler
+    {
+    public:
+        inline explicit NppStStreamHandler(cudaStream_t newStream = 0)
         {
-            const textureReference* tex; 
-            cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
-            cudaSafeCall( cudaUnbindTexture(tex) );
+            oldStream = nppStSetActiveCUDAstream(newStream);
         }
 
-        class TextureBinder
-        {
-        public:
-            TextureBinder() : tex_(0) {}
-            template <typename T> TextureBinder(const textureReference* tex, const DevMem2D_<T>& img) : tex_(0)
-            {
-                bind(tex, img);
-            }
-            template <typename T> TextureBinder(const char* tex_name, const DevMem2D_<T>& img) : tex_(0)
-            {
-                bind(tex_name, img);
-            }
-            ~TextureBinder() { unbind(); }
-
-            template <typename T> void bind(const textureReference* tex, const DevMem2D_<T>& img)
-            {
-                unbind();
-
-                cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
-                cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
-
-                tex_ = tex;
-            }
-            template <typename T> void bind(const char* tex_name, const DevMem2D_<T>& img)
-            {
-                const textureReference* tex; 
-                cudaSafeCall( cudaGetTextureReference(&tex, tex_name) ); 
-                bind(tex, img);
-            }
-
-            void unbind()
-            {
-                if (tex_)
-                {
-                    cudaUnbindTexture(tex_);
-                    tex_ = 0;
-                }
-            }
-
-        private:
-            const textureReference* tex_;
-        };
-
-        class NppStreamHandler
-        {
-        public:
-            inline explicit NppStreamHandler(cudaStream_t newStream = 0)
-            {
-                oldStream = nppGetStream();
-                nppSetStream(newStream);
-            }
-
-            inline ~NppStreamHandler()
-            {
-                nppSetStream(oldStream);
-            }
-
-        private:
-            cudaStream_t oldStream;
-        };
-
-        class NppStStreamHandler
+        inline ~NppStStreamHandler()
         {
-        public:
-            inline explicit NppStStreamHandler(cudaStream_t newStream = 0)
-            {
-                oldStream = nppStSetActiveCUDAstream(newStream);
-            }
-
-            inline ~NppStStreamHandler()
-            {
-                nppStSetActiveCUDAstream(oldStream);
-            }
-
-        private:
-            cudaStream_t oldStream;
-        };
-    }
-}
+            nppStSetActiveCUDAstream(oldStream);
+        }
 
+    private:
+        cudaStream_t oldStream;
+    };
+}}
 
 #endif /* __OPENCV_internal_shared_HPP__ */
diff --git a/modules/gpu/src/cuda/match_template.cu b/modules/gpu/src/cuda/match_template.cu
index e954a26635fc0c754fcb76e421aca0b6ca53a207..1fa571ad8b5e201775182d36097eba1336949a6f 100644
--- a/modules/gpu/src/cuda/match_template.cu
+++ b/modules/gpu/src/cuda/match_template.cu
@@ -43,10 +43,9 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc {
+namespace match_template {
 
 __device__ __forceinline__ float sum(float v) { return v; }
 __device__ __forceinline__ float sum(float2 v) { return v.x + v.y; }
@@ -266,9 +265,9 @@ void matchTemplatePrepared_SQDIFF_8U(int w, int h, const DevMem2D_<unsigned long
 
 __device__ float normAcc(float num, float denum)
 {
-    if (fabs(num) < denum)
+    if (::fabs(num) < denum)
         return num / denum;
-    if (fabs(num) < denum * 1.125f)
+    if (::fabs(num) < denum * 1.125f)
         return num > 0 ? 1 : -1;
     return 0;
 }
@@ -276,9 +275,9 @@ __device__ float normAcc(float num, float denum)
 
 __device__ float normAcc_SQDIFF(float num, float denum)
 {
-    if (fabs(num) < denum)
+    if (::fabs(num) < denum)
         return num / denum;
-    if (fabs(num) < denum * 1.125f)
+    if (::fabs(num) < denum * 1.125f)
         return num > 0 ? 1 : -1;
     return 1;
 }
@@ -906,4 +905,7 @@ void extractFirstChannel_32F(const DevMem2Db image, DevMem2Df result, int cn, cu
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
 }
-}}}
+
+} //namespace match_template
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/mathfunc.cu b/modules/gpu/src/cuda/mathfunc.cu
index 0a644d46ddf6a01e7ab2c11e0adab5a542f3f4d7..3b427fcea22211f1f1a530f7b84a5d60d7b17e55 100644
--- a/modules/gpu/src/cuda/mathfunc.cu
+++ b/modules/gpu/src/cuda/mathfunc.cu
@@ -42,178 +42,174 @@
 
 #include "internal_shared.hpp"
 
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-#ifndef CV_PI
-#define CV_PI   3.1415926535897932384626433832795f
-#endif
+namespace mathfunc {
 
 //////////////////////////////////////////////////////////////////////////////////////
 // Cart <-> Polar
 
-namespace cv { namespace gpu { namespace mathfunc
+struct Nothing
 {
-    struct Nothing
+    static __device__ __forceinline__ void calc(int, int, float, float, float*, size_t, float)
     {
-        static __device__ __forceinline__ void calc(int, int, float, float, float*, size_t, float)
-        {
-        }
-    };
-    struct Magnitude
-    {
-        static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
-        {
-            dst[y * dst_step + x] = sqrtf(x_data * x_data + y_data * y_data);
-        }
-    };
-    struct MagnitudeSqr
+    }
+};
+struct Magnitude
+{
+    static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
     {
-        static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
-        {
-            dst[y * dst_step + x] = x_data * x_data + y_data * y_data;
-        }
-    };
-    struct Atan2
+        dst[y * dst_step + x] = ::sqrtf(x_data * x_data + y_data * y_data);
+    }
+};
+struct MagnitudeSqr
+{
+    static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
     {
-        static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float scale)
-        {
-            float angle = atan2f(y_data, x_data);
-            angle += (angle < 0) * 2.0 * CV_PI;
-            dst[y * dst_step + x] = scale * angle;
-        }
-    };
-    template <typename Mag, typename Angle>
-    __global__ void cartToPolar(const float* xptr, size_t x_step, const float* yptr, size_t y_step, 
-                                float* mag, size_t mag_step, float* angle, size_t angle_step, float scale, int width, int height)
+        dst[y * dst_step + x] = x_data * x_data + y_data * y_data;
+    }
+};
+struct Atan2
+{
+    static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float scale)
     {
-		const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        float angle = ::atan2f(y_data, x_data);
+        angle += (angle < 0) * 2.0 * CV_PI;
+        dst[y * dst_step + x] = scale * angle;
+    }
+};
+template <typename Mag, typename Angle>
+__global__ void cartToPolar(const float* xptr, size_t x_step, const float* yptr, size_t y_step, 
+                            float* mag, size_t mag_step, float* angle, size_t angle_step, float scale, int width, int height)
+{
+	const int x = blockDim.x * blockIdx.x + threadIdx.x;
+	const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-        if (x < width && y < height)
-        {
-            float x_data = xptr[y * x_step + x];
-            float y_data = yptr[y * y_step + x];
+    if (x < width && y < height)
+    {
+        float x_data = xptr[y * x_step + x];
+        float y_data = yptr[y * y_step + x];
 
-            Mag::calc(x, y, x_data, y_data, mag, mag_step, scale);
-            Angle::calc(x, y, x_data, y_data, angle, angle_step, scale);
-        }
+        Mag::calc(x, y, x_data, y_data, mag, mag_step, scale);
+        Angle::calc(x, y, x_data, y_data, angle, angle_step, scale);
     }
+}
 
-    struct NonEmptyMag
-    {
-        static __device__ __forceinline__ float get(const float* mag, size_t mag_step, int x, int y)
-        {
-            return mag[y * mag_step + x];
-        }
-    };
-    struct EmptyMag
+struct NonEmptyMag
+{
+    static __device__ __forceinline__ float get(const float* mag, size_t mag_step, int x, int y)
     {
-        static __device__ __forceinline__ float get(const float*, size_t, int, int)
-        {
-            return 1.0f;
-        }
-    };
-    template <typename Mag>
-    __global__ void polarToCart(const float* mag, size_t mag_step, const float* angle, size_t angle_step, float scale,
-        float* xptr, size_t x_step, float* yptr, size_t y_step, int width, int height)
+        return mag[y * mag_step + x];
+    }
+};
+struct EmptyMag
+{
+    static __device__ __forceinline__ float get(const float*, size_t, int, int)
     {
-		const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        return 1.0f;
+    }
+};
+template <typename Mag>
+__global__ void polarToCart(const float* mag, size_t mag_step, const float* angle, size_t angle_step, float scale,
+    float* xptr, size_t x_step, float* yptr, size_t y_step, int width, int height)
+{
+	const int x = blockDim.x * blockIdx.x + threadIdx.x;
+	const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-        if (x < width && y < height)
-        {
-            float mag_data = Mag::get(mag, mag_step, x, y);
-            float angle_data = angle[y * angle_step + x];
-            float sin_a, cos_a;
+    if (x < width && y < height)
+    {
+        float mag_data = Mag::get(mag, mag_step, x, y);
+        float angle_data = angle[y * angle_step + x];
+        float sin_a, cos_a;
 
-            sincosf(scale * angle_data, &sin_a, &cos_a);
+        ::sincosf(scale * angle_data, &sin_a, &cos_a);
 
-            xptr[y * x_step + x] = mag_data * cos_a;
-            yptr[y * y_step + x] = mag_data * sin_a;
-        }
+        xptr[y * x_step + x] = mag_data * cos_a;
+        yptr[y * y_step + x] = mag_data * sin_a;
     }
+}
 
-    template <typename Mag, typename Angle>
-    void cartToPolar_caller(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename Mag, typename Angle>
+void cartToPolar_caller(DevMem2Df x, DevMem2Df y, DevMem2Df mag, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(x.cols, threads.x);
-        grid.y = divUp(x.rows, threads.y);
-        
-        const float scale = angleInDegrees ? (float)(180.0f / CV_PI) : 1.f;
+    grid.x = divUp(x.cols, threads.x);
+    grid.y = divUp(x.rows, threads.y);
+    
+    const float scale = angleInDegrees ? (float)(180.0f / CV_PI) : 1.f;
 
-        cartToPolar<Mag, Angle><<<grid, threads, 0, stream>>>(
-            x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), 
-            mag.data, mag.step/mag.elemSize(), angle.data, angle.step/angle.elemSize(), scale, x.cols, x.rows);
-        cudaSafeCall( cudaGetLastError() );
+    cartToPolar<Mag, Angle><<<grid, threads, 0, stream>>>(
+        x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), 
+        mag.data, mag.step/mag.elemSize(), angle.data, angle.step/angle.elemSize(), scale, x.cols, x.rows);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    void cartToPolar_gpu(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, bool magSqr, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream)
+void cartToPolar_gpu(DevMem2Df x, DevMem2Df y, DevMem2Df mag, bool magSqr, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream)
+{
+    typedef void (*caller_t)(DevMem2Df x, DevMem2Df y, DevMem2Df mag, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream);
+    static const caller_t callers[2][2][2] = 
     {
-        typedef void (*caller_t)(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream);
-        static const caller_t callers[2][2][2] = 
         {
             {
-                {
-                    cartToPolar_caller<Magnitude, Atan2>,
-                    cartToPolar_caller<Magnitude, Nothing>
-                },
-                {
-                    cartToPolar_caller<MagnitudeSqr, Atan2>,
-                    cartToPolar_caller<MagnitudeSqr, Nothing>,
-                }
+                cartToPolar_caller<Magnitude, Atan2>,
+                cartToPolar_caller<Magnitude, Nothing>
             },
             {
-                {
-                    cartToPolar_caller<Nothing, Atan2>,
-                    cartToPolar_caller<Nothing, Nothing>
-                },
-                {
-                    cartToPolar_caller<Nothing, Atan2>,
-                    cartToPolar_caller<Nothing, Nothing>,
-                }
+                cartToPolar_caller<MagnitudeSqr, Atan2>,
+                cartToPolar_caller<MagnitudeSqr, Nothing>,
             }
-        };
+        },
+        {
+            {
+                cartToPolar_caller<Nothing, Atan2>,
+                cartToPolar_caller<Nothing, Nothing>
+            },
+            {
+                cartToPolar_caller<Nothing, Atan2>,
+                cartToPolar_caller<Nothing, Nothing>,
+            }
+        }
+    };
 
-        callers[mag.data == 0][magSqr][angle.data == 0](x, y, mag, angle, angleInDegrees, stream);
-    }
+    callers[mag.data == 0][magSqr][angle.data == 0](x, y, mag, angle, angleInDegrees, stream);
+}
 
-    template <typename Mag>
-    void polarToCart_caller(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename Mag>
+void polarToCart_caller(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(mag.cols, threads.x);
-        grid.y = divUp(mag.rows, threads.y);
-        
-        const float scale = angleInDegrees ? (float)(CV_PI / 180.0f) : 1.0f;
+    grid.x = divUp(mag.cols, threads.x);
+    grid.y = divUp(mag.rows, threads.y);
+    
+    const float scale = angleInDegrees ? (float)(CV_PI / 180.0f) : 1.0f;
 
-        polarToCart<Mag><<<grid, threads, 0, stream>>>(mag.data, mag.step/mag.elemSize(), 
-            angle.data, angle.step/angle.elemSize(), scale, x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), mag.cols, mag.rows);
-        cudaSafeCall( cudaGetLastError() );
+    polarToCart<Mag><<<grid, threads, 0, stream>>>(mag.data, mag.step/mag.elemSize(), 
+        angle.data, angle.step/angle.elemSize(), scale, x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), mag.cols, mag.rows);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    void polarToCart_gpu(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream)
+void polarToCart_gpu(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream)
+{
+    typedef void (*caller_t)(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream);
+    static const caller_t callers[2] = 
     {
-        typedef void (*caller_t)(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream);
-        static const caller_t callers[2] = 
-        {
-            polarToCart_caller<NonEmptyMag>,
-            polarToCart_caller<EmptyMag>
-        };
-
-        callers[mag.data == 0](mag, angle, x, y, angleInDegrees, stream);
-    }
-}}}
+        polarToCart_caller<NonEmptyMag>,
+        polarToCart_caller<EmptyMag>
+    };
 
+    callers[mag.data == 0](mag, angle, x, y, angleInDegrees, stream);
+}
 
+} // namespace mathfunc
 
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/matrix_operations.cu b/modules/gpu/src/cuda/matrix_operations.cu
index b2def00b639bc7d136962328a3d60ba7a0eb4759..df200ed65d3dec902b3fb06a8e143c89129d44b2 100644
--- a/modules/gpu/src/cuda/matrix_operations.cu
+++ b/modules/gpu/src/cuda/matrix_operations.cu
@@ -45,302 +45,304 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 
-namespace cv { namespace gpu { namespace device {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T> struct shift_and_sizeof;
-    template <> struct shift_and_sizeof<signed char> { enum { shift = 0 }; };
-    template <> struct shift_and_sizeof<unsigned char> { enum { shift = 0 }; };
-    template <> struct shift_and_sizeof<short> { enum { shift = 1 }; };
-    template <> struct shift_and_sizeof<unsigned short> { enum { shift = 1 }; };
-    template <> struct shift_and_sizeof<int> { enum { shift = 2 }; };
-    template <> struct shift_and_sizeof<float> { enum { shift = 2 }; };
-    template <> struct shift_and_sizeof<double> { enum { shift = 3 }; };
+template <typename T> struct shift_and_sizeof;
+template <> struct shift_and_sizeof<signed char> { enum { shift = 0 }; };
+template <> struct shift_and_sizeof<unsigned char> { enum { shift = 0 }; };
+template <> struct shift_and_sizeof<short> { enum { shift = 1 }; };
+template <> struct shift_and_sizeof<unsigned short> { enum { shift = 1 }; };
+template <> struct shift_and_sizeof<int> { enum { shift = 2 }; };
+template <> struct shift_and_sizeof<float> { enum { shift = 2 }; };
+template <> struct shift_and_sizeof<double> { enum { shift = 3 }; };
 
 ///////////////////////////////////////////////////////////////////////////
 ////////////////////////////////// CopyTo /////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    template<typename T>
-    __global__ void copy_to_with_mask(const T* mat_src, T* mat_dst, const uchar* mask, int cols, int rows, size_t step_mat, size_t step_mask, int channels)
-    {
-        size_t x = blockIdx.x * blockDim.x + threadIdx.x;
-        size_t y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if ((x < cols * channels ) && (y < rows))
-            if (mask[y * step_mask + x / channels] != 0)
-            {
-                size_t idx = y * ( step_mat >> shift_and_sizeof<T>::shift ) + x;
-                mat_dst[idx] = mat_src[idx];
-            }
-    }
-    typedef void (*CopyToFunc)(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream);
+template<typename T>
+__global__ void copy_to_with_mask(const T* mat_src, T* mat_dst, const uchar* mask, int cols, int rows, size_t step_mat, size_t step_mask, int channels)
+{
+    size_t x = blockIdx.x * blockDim.x + threadIdx.x;
+    size_t y = blockIdx.y * blockDim.y + threadIdx.y;
 
-    template<typename T>
-    void copy_to_with_mask_run(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
-    {
-        dim3 threadsPerBlock(16,16, 1);
-        dim3 numBlocks ( divUp(mat_src.cols * channels , threadsPerBlock.x) , divUp(mat_src.rows , threadsPerBlock.y), 1);
+    if ((x < cols * channels ) && (y < rows))
+        if (mask[y * step_mask + x / channels] != 0)
+        {
+            size_t idx = y * ( step_mat >> shift_and_sizeof<T>::shift ) + x;
+            mat_dst[idx] = mat_src[idx];
+        }
+}
 
-        copy_to_with_mask<T><<<numBlocks,threadsPerBlock, 0, stream>>>
-                ((T*)mat_src.data, (T*)mat_dst.data, (unsigned char*)mask.data, mat_src.cols, mat_src.rows, mat_src.step, mask.step, channels);
-        cudaSafeCall( cudaGetLastError() );
+template<typename T>
+void copy_to_with_mask_run(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+{
+    dim3 threadsPerBlock(16,16, 1);
+    dim3 numBlocks ( divUp(mat_src.cols * channels , threadsPerBlock.x) , divUp(mat_src.rows , threadsPerBlock.y), 1);
 
-        if (stream == 0)
-            cudaSafeCall ( cudaDeviceSynchronize() );
-    }
+    copy_to_with_mask<T><<<numBlocks,threadsPerBlock, 0, stream>>>
+            ((T*)mat_src.data, (T*)mat_dst.data, (unsigned char*)mask.data, mat_src.cols, mat_src.rows, mat_src.step, mask.step, channels);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall ( cudaDeviceSynchronize() );
+}
+
+void copy_to_with_mask(const DevMem2Db& mat_src, DevMem2Db mat_dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+{
+    typedef void (*CopyToFunc)(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream);
 
-    void copy_to_with_mask(const DevMem2Db& mat_src, DevMem2Db mat_dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+    static CopyToFunc tab[8] =
     {
-        static CopyToFunc tab[8] =
-        {
-            copy_to_with_mask_run<unsigned char>,
-            copy_to_with_mask_run<signed char>,
-            copy_to_with_mask_run<unsigned short>,
-            copy_to_with_mask_run<short>,
-            copy_to_with_mask_run<int>,
-            copy_to_with_mask_run<float>,
-            copy_to_with_mask_run<double>,
-            0
-        };
+        copy_to_with_mask_run<unsigned char>,
+        copy_to_with_mask_run<signed char>,
+        copy_to_with_mask_run<unsigned short>,
+        copy_to_with_mask_run<short>,
+        copy_to_with_mask_run<int>,
+        copy_to_with_mask_run<float>,
+        copy_to_with_mask_run<double>,
+        0
+    };
 
-        CopyToFunc func = tab[depth];
+    CopyToFunc func = tab[depth];
 
-        if (func == 0) cv::gpu::error("Unsupported copyTo operation", __FILE__, __LINE__);
+    if (func == 0) cv::gpu::error("Unsupported copyTo operation", __FILE__, __LINE__);
 
-        func(mat_src, mat_dst, mask, channels, stream);
-    }
+    func(mat_src, mat_dst, mask, channels, stream);
+}
 
 ///////////////////////////////////////////////////////////////////////////
 ////////////////////////////////// SetTo //////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    __constant__ uchar scalar_8u[4];
-    __constant__ schar scalar_8s[4];
-    __constant__ ushort scalar_16u[4];
-    __constant__ short scalar_16s[4];
-    __constant__ int scalar_32s[4];
-    __constant__ float scalar_32f[4]; 
-    __constant__ double scalar_64f[4];
-
-    template <typename T> __device__ __forceinline__ T readScalar(int i);
-    template <> __device__ __forceinline__ uchar readScalar<uchar>(int i) {return scalar_8u[i];}
-    template <> __device__ __forceinline__ schar readScalar<schar>(int i) {return scalar_8s[i];}
-    template <> __device__ __forceinline__ ushort readScalar<ushort>(int i) {return scalar_16u[i];}
-    template <> __device__ __forceinline__ short readScalar<short>(int i) {return scalar_16s[i];}
-    template <> __device__ __forceinline__ int readScalar<int>(int i) {return scalar_32s[i];}
-    template <> __device__ __forceinline__ float readScalar<float>(int i) {return scalar_32f[i];}
-    template <> __device__ __forceinline__ double readScalar<double>(int i) {return scalar_64f[i];}
-
-    void writeScalar(const uchar* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_8u, vals, sizeof(uchar) * 4) );
-    }
-    void writeScalar(const schar* vals)
+__constant__ uchar scalar_8u[4];
+__constant__ schar scalar_8s[4];
+__constant__ ushort scalar_16u[4];
+__constant__ short scalar_16s[4];
+__constant__ int scalar_32s[4];
+__constant__ float scalar_32f[4]; 
+__constant__ double scalar_64f[4];
+
+template <typename T> __device__ __forceinline__ T readScalar(int i);
+template <> __device__ __forceinline__ uchar readScalar<uchar>(int i) {return scalar_8u[i];}
+template <> __device__ __forceinline__ schar readScalar<schar>(int i) {return scalar_8s[i];}
+template <> __device__ __forceinline__ ushort readScalar<ushort>(int i) {return scalar_16u[i];}
+template <> __device__ __forceinline__ short readScalar<short>(int i) {return scalar_16s[i];}
+template <> __device__ __forceinline__ int readScalar<int>(int i) {return scalar_32s[i];}
+template <> __device__ __forceinline__ float readScalar<float>(int i) {return scalar_32f[i];}
+template <> __device__ __forceinline__ double readScalar<double>(int i) {return scalar_64f[i];}
+
+void writeScalar(const uchar* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_8u, vals, sizeof(uchar) * 4) );
+}
+void writeScalar(const schar* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_8s, vals, sizeof(schar) * 4) );
+}
+void writeScalar(const ushort* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_16u, vals, sizeof(ushort) * 4) );
+}
+void writeScalar(const short* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_16s, vals, sizeof(short) * 4) );
+}
+void writeScalar(const int* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_32s, vals, sizeof(int) * 4) );
+}
+void writeScalar(const float* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_32f, vals, sizeof(float) * 4) );
+}
+void writeScalar(const double* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_64f, vals, sizeof(double) * 4) );
+}
+
+template<typename T>
+__global__ void set_to_without_mask(T* mat, int cols, int rows, size_t step, int channels)
+{
+    size_t x = blockIdx.x * blockDim.x + threadIdx.x;
+    size_t y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if ((x < cols * channels ) && (y < rows))
     {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_8s, vals, sizeof(schar) * 4) );
-    }
-    void writeScalar(const ushort* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_16u, vals, sizeof(ushort) * 4) );
-    }
-    void writeScalar(const short* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_16s, vals, sizeof(short) * 4) );
-    }
-    void writeScalar(const int* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_32s, vals, sizeof(int) * 4) );
-    }
-    void writeScalar(const float* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_32f, vals, sizeof(float) * 4) );
-    }
-    void writeScalar(const double* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_64f, vals, sizeof(double) * 4) );
+        size_t idx = y * ( step >> shift_and_sizeof<T>::shift ) + x;
+        mat[idx] = readScalar<T>(x % channels);
     }
+}
 
-    template<typename T>
-    __global__ void set_to_without_mask(T* mat, int cols, int rows, size_t step, int channels)
-    {
-        size_t x = blockIdx.x * blockDim.x + threadIdx.x;
-        size_t y = blockIdx.y * blockDim.y + threadIdx.y;
+template<typename T>
+__global__ void set_to_with_mask(T* mat, const uchar* mask, int cols, int rows, size_t step, int channels, size_t step_mask)
+{
+    size_t x = blockIdx.x * blockDim.x + threadIdx.x;
+    size_t y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if ((x < cols * channels ) && (y < rows))
+    if ((x < cols * channels ) && (y < rows))
+        if (mask[y * step_mask + x / channels] != 0)
         {
             size_t idx = y * ( step >> shift_and_sizeof<T>::shift ) + x;
             mat[idx] = readScalar<T>(x % channels);
         }
-    }
-
-    template<typename T>
-    __global__ void set_to_with_mask(T* mat, const uchar* mask, int cols, int rows, size_t step, int channels, size_t step_mask)
-    {
-        size_t x = blockIdx.x * blockDim.x + threadIdx.x;
-        size_t y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if ((x < cols * channels ) && (y < rows))
-            if (mask[y * step_mask + x / channels] != 0)
-            {
-                size_t idx = y * ( step >> shift_and_sizeof<T>::shift ) + x;
-                mat[idx] = readScalar<T>(x % channels);
-            }
-    }
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream)
-    {
-        writeScalar(scalar);
-
-        dim3 threadsPerBlock(32, 8, 1);
-        dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
-
-        set_to_with_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, (uchar*)mask.data, mat.cols, mat.rows, mat.step, channels, mask.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall ( cudaDeviceSynchronize() );
-    }
-
-    template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream)
-    {
-        writeScalar(scalar);
-
-        dim3 threadsPerBlock(32, 8, 1);
-        dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
-
-        set_to_without_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, mat.cols, mat.rows, mat.step, channels);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall ( cudaDeviceSynchronize() );
-    }
-
-    template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, int channels, cudaStream_t stream);
+}
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream)
+{
+    writeScalar(scalar);
+
+    dim3 threadsPerBlock(32, 8, 1);
+    dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
+
+    set_to_with_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, (uchar*)mask.data, mat.cols, mat.rows, mat.step, channels, mask.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall ( cudaDeviceSynchronize() );
+}
+
+template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream)
+{
+    writeScalar(scalar);
+
+    dim3 threadsPerBlock(32, 8, 1);
+    dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
+
+    set_to_without_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, mat.cols, mat.rows, mat.step, channels);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall ( cudaDeviceSynchronize() );
+}
+
+template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, int channels, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////////////////
 //////////////////////////////// ConvertTo ////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    template <typename T, typename D> struct Convertor : unary_function<T, D>
+template <typename T, typename D> struct Convertor : unary_function<T, D>
+{
+    Convertor(double alpha_, double beta_) : alpha(alpha_), beta(beta_) {}
+
+    __device__ __forceinline__ D operator()(const T& src) const
     {
-        Convertor(double alpha_, double beta_) : alpha(alpha_), beta(beta_) {}
+        return saturate_cast<D>(alpha * src + beta);
+    }
 
-        __device__ __forceinline__ D operator()(const T& src) const
-        {
-            return saturate_cast<D>(alpha * src + beta);
-        }
+    const double alpha, beta;
+};
 
-        const double alpha, beta;
+namespace detail
+{
+    template <size_t src_size, size_t dst_size, typename F> struct ConvertTraitsDispatcher : DefaultTransformFunctorTraits<F>
+    {
     };
-
-    namespace detail
+    template <typename F> struct ConvertTraitsDispatcher<1, 1, F> : DefaultTransformFunctorTraits<F>
     {
-        template <size_t src_size, size_t dst_size, typename F> struct ConvertTraitsDispatcher : DefaultTransformFunctorTraits<F>
-        {
-        };
-        template <typename F> struct ConvertTraitsDispatcher<1, 1, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 8 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<1, 2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<1, 4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 4 };
-        };
-
-        template <typename F> struct ConvertTraitsDispatcher<2, 2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<2, 4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 2 };
-        };
-
-        template <typename F> struct ConvertTraitsDispatcher<4, 2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<4, 4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 2 };
-        };
+        enum { smart_shift = 8 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<1, 2, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_shift = 4 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<1, 4, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
 
-        template <typename F> struct ConvertTraits : ConvertTraitsDispatcher<sizeof(typename F::argument_type), sizeof(typename F::result_type), F>
-        {
-        };
-    }
+    template <typename F> struct ConvertTraitsDispatcher<2, 2, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_shift = 4 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<2, 4, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_shift = 2 };
+    };
 
-    template <typename T, typename D> struct TransformFunctorTraits< Convertor<T, D> > : detail::ConvertTraits< Convertor<T, D> >
+    template <typename F> struct ConvertTraitsDispatcher<4, 2, F> : DefaultTransformFunctorTraits<F>
     {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
     };
-        
-    template<typename T, typename D>
-    void cvt_(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, cudaStream_t stream)
+    template <typename F> struct ConvertTraitsDispatcher<4, 4, F> : DefaultTransformFunctorTraits<F>
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
-        cudaSafeCall( cudaSetDoubleForDevice(&beta) );
-        Convertor<T, D> op(alpha, beta);
-        transform((DevMem2D_<T>)src, (DevMem2D_<D>)dst, op, stream);
-    }
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 2 };
+    };
 
-    void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, 
-        cudaStream_t stream = 0)
+    template <typename F> struct ConvertTraits : ConvertTraitsDispatcher<sizeof(typename F::argument_type), sizeof(typename F::result_type), F>
     {
-        typedef void (*caller_t)(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, 
-            cudaStream_t stream);
+    };
+}
+
+template <typename T, typename D> struct TransformFunctorTraits< Convertor<T, D> > : detail::ConvertTraits< Convertor<T, D> >
+{
+};
+    
+template<typename T, typename D>
+void cvt_(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
+    cudaSafeCall( cudaSetDoubleForDevice(&beta) );
+    Convertor<T, D> op(alpha, beta);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src, (DevMem2D_<D>)dst, op, stream);
+}
+
+void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, 
+    cudaStream_t stream = 0)
+{
+    typedef void (*caller_t)(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, 
+        cudaStream_t stream);
+
+    static const caller_t tab[8][8] =
+    {
+        {cvt_<uchar, uchar>, cvt_<uchar, schar>, cvt_<uchar, ushort>, cvt_<uchar, short>,
+        cvt_<uchar, int>, cvt_<uchar, float>, cvt_<uchar, double>, 0},
 
-        static const caller_t tab[8][8] =
-        {
-            {cvt_<uchar, uchar>, cvt_<uchar, schar>, cvt_<uchar, ushort>, cvt_<uchar, short>,
-            cvt_<uchar, int>, cvt_<uchar, float>, cvt_<uchar, double>, 0},
+        {cvt_<schar, uchar>, cvt_<schar, schar>, cvt_<schar, ushort>, cvt_<schar, short>,
+        cvt_<schar, int>, cvt_<schar, float>, cvt_<schar, 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_<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_<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_<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_<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},
 
-            {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}
+    };
 
-            {0,0,0,0,0,0,0,0}
-        };
+    caller_t func = tab[sdepth][ddepth];
+    if (!func)
+        cv::gpu::error("Unsupported convert operation", __FILE__, __LINE__);
 
-        caller_t func = tab[sdepth][ddepth];
-        if (!func)
-            cv::gpu::error("Unsupported convert operation", __FILE__, __LINE__);
+    func(src, dst, alpha, beta, stream);
+}
 
-        func(src, dst, alpha, beta, stream);
-    }
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/matrix_reductions.cu b/modules/gpu/src/cuda/matrix_reductions.cu
index c0ca6c858487e9c3791f0ffb8e57a92a42539872..618e94aaafa87f3353c513218543ec3f20160288 100644
--- a/modules/gpu/src/cuda/matrix_reductions.cu
+++ b/modules/gpu/src/cuda/matrix_reductions.cu
@@ -40,79 +40,73 @@
 //
 //M*/
 
+#include "internal_shared.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/transform.hpp"
-#include "internal_shared.hpp"
-
-using namespace cv::gpu;
-using namespace cv::gpu::device;
 
-namespace cv { namespace gpu { namespace mathfunc
-{
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    // Performs reduction in shared memory
-    template <int size, typename T>
-    __device__ void sumInSmem(volatile T* data, const uint tid)
-    {
-        T sum = data[tid];
+namespace matrix_reductions {
 
-        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];
-        }
-    }
+// Performs reduction in shared memory
+template <int size, typename T>
+__device__ void sumInSmem(volatile T* data, const uint tid)
+{
+    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(); }
 
-    struct Mask8U
+    if (tid < 32)
     {
-        explicit Mask8U(PtrStepb mask): mask(mask) {}
-
-        __device__ __forceinline__ bool operator()(int y, int x) const 
-        { 
-            return mask.ptr(y)[x]; 
-        }
-
-        PtrStepb mask;
-    };
+        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];
+    }
+}
 
+struct Mask8U
+{
+    explicit Mask8U(PtrStepb mask): mask(mask) {}
 
-    struct MaskTrue 
+    __device__ __forceinline__ bool operator()(int y, int x) const 
     { 
-        __device__ __forceinline__ bool operator()(int y, int x) const 
-        { 
-            return true; 
-        } 
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // 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; };
-
+        return mask.ptr(y)[x]; 
+    }
 
-    namespace minmax 
-    {
+    PtrStepb mask;
+};
 
+struct MaskTrue 
+{ 
+    __device__ __forceinline__ bool operator()(int y, int x) const 
+    { 
+        return true; 
+    } 
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// 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 
+{
     __constant__ int ctwidth;
     __constant__ int ctheight;
 
@@ -126,8 +120,8 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         threads = dim3(32, 8);
         grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -155,8 +149,8 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     __device__ __forceinline__ void merge(uint tid, uint offset, volatile T* minval, volatile T* maxval)
     {
-        minval[tid] = min(minval[tid], minval[tid + offset]);
-        maxval[tid] = max(maxval[tid], maxval[tid + offset]);
+        minval[tid] = ::min(minval[tid], minval[tid + offset]);
+        maxval[tid] = ::max(maxval[tid], maxval[tid + offset]);
     }
 
 
@@ -192,8 +186,8 @@ namespace cv { namespace gpu { namespace mathfunc
 
         T mymin = numeric_limits<T>::max();
         T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : numeric_limits<T>::min();
-        uint y_end = min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
-        uint x_end = min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
+        uint y_end = ::min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
+        uint x_end = ::min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
         for (uint y = y0; y < y_end; y += blockDim.y)
         {
             const T* src_row = (const T*)src.ptr(y);
@@ -202,8 +196,8 @@ namespace cv { namespace gpu { namespace mathfunc
                 T val = src_row[x];
                 if (mask(y, x)) 
                 { 
-                    mymin = min(mymin, val); 
-                    mymax = max(mymax, val); 
+                    mymin = ::min(mymin, val); 
+                    mymax = ::max(mymax, val); 
                 }
             }
         }
@@ -220,7 +214,7 @@ namespace cv { namespace gpu { namespace mathfunc
             maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
         }
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
 		__shared__ bool is_last;
 
 		if (tid == 0)
@@ -237,7 +231,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
 		if (is_last)
 		{
-            uint idx = min(tid, gridDim.x * gridDim.y - 1);
+            uint idx = ::min(tid, gridDim.x * gridDim.y - 1);
 
             sminval[tid] = minval[idx];
             smaxval[tid] = maxval[idx];
@@ -332,7 +326,7 @@ namespace cv { namespace gpu { namespace mathfunc
         __shared__ best_type smaxval[nthreads];
         
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-        uint idx = min(tid, size - 1);
+        uint idx = ::min(tid, size - 1);
 
         sminval[tid] = minval[idx];
         smaxval[tid] = maxval[idx];
@@ -410,14 +404,13 @@ namespace cv { namespace gpu { namespace mathfunc
     template void minMaxMultipassCaller<short>(const DevMem2Db, double*, double*, PtrStepb);
     template void minMaxMultipassCaller<int>(const DevMem2Db, double*, double*, PtrStepb);
     template void minMaxMultipassCaller<float>(const DevMem2Db, double*, double*, PtrStepb);
-
-    } // namespace minmax
+} // namespace minmax
 
 ///////////////////////////////////////////////////////////////////////////////
 // minMaxLoc
 
-    namespace minmaxloc {
-
+namespace minmaxloc 
+{
     __constant__ int ctwidth;
     __constant__ int ctheight;
 
@@ -431,8 +424,8 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         threads = dim3(32, 8);
         grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -513,12 +506,11 @@ namespace cv { namespace gpu { namespace mathfunc
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
 
         T mymin = numeric_limits<T>::max();
-        T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : 
-                                                     numeric_limits<T>::min(); 
+        T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : numeric_limits<T>::min(); 
         uint myminloc = 0;
         uint mymaxloc = 0;
-        uint y_end = min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
-        uint x_end = min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
+        uint y_end = ::min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
+        uint x_end = ::min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
 
         for (uint y = y0; y < y_end; y += blockDim.y)
         {
@@ -542,7 +534,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
         findMinMaxLocInSmem<nthreads, best_type>(sminval, smaxval, sminloc, smaxloc, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
 		__shared__ bool is_last;
 
 		if (tid == 0)
@@ -561,7 +553,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
 		if (is_last)
 		{
-            uint idx = min(tid, gridDim.x * gridDim.y - 1);
+            uint idx = ::min(tid, gridDim.x * gridDim.y - 1);
 
             sminval[tid] = minval[idx];
             smaxval[tid] = maxval[idx];
@@ -685,7 +677,7 @@ namespace cv { namespace gpu { namespace mathfunc
         __shared__ uint smaxloc[nthreads];
 
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-        uint idx = min(tid, size - 1);
+        uint idx = ::min(tid, size - 1);
 
         sminval[tid] = minval[idx];
         smaxval[tid] = maxval[idx];
@@ -787,15 +779,13 @@ namespace cv { namespace gpu { namespace mathfunc
     template void minMaxLocMultipassCaller<short>(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
     template void minMaxLocMultipassCaller<int>(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
     template void minMaxLocMultipassCaller<float>(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-
-    } // namespace minmaxloc
+} // namespace minmaxloc
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 // countNonZero
 
-    namespace countnonzero 
-    {
-
+namespace countnonzero 
+{
     __constant__ int ctwidth;
     __constant__ int ctheight;
 
@@ -805,8 +795,8 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         threads = dim3(32, 8);
         grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -850,7 +840,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
         sumInSmem<nthreads, uint>(scount, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
 		__shared__ bool is_last;
 
 		if (tid == 0)
@@ -957,15 +947,14 @@ namespace cv { namespace gpu { namespace mathfunc
     template int countNonZeroMultipassCaller<int>(const DevMem2Db, PtrStepb);
     template int countNonZeroMultipassCaller<float>(const DevMem2Db, PtrStepb);
 
-    } // namespace countnonzero
+} // namespace countnonzero
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // Sum
-
-    namespace sums 
-    {
+//////////////////////////////////////////////////////////////////////////
+// Sum
 
+namespace sum
+{
     template <typename T> struct SumType {};
     template <> struct SumType<uchar> { typedef uint R; };
     template <> struct SumType<char> { typedef int R; };
@@ -979,7 +968,7 @@ namespace cv { namespace gpu { namespace mathfunc
     struct IdentityOp { static __device__ __forceinline__ R call(R x) { return x; } };
 
     template <typename R> 
-    struct AbsOp { static __device__ __forceinline__ R call(R x) { return abs(x); } };
+    struct AbsOp { static __device__ __forceinline__ R call(R x) { return ::abs(x); } };
 
     template <>
     struct AbsOp<uint> { static __device__ __forceinline__ uint call(uint x) { return x; } };
@@ -999,8 +988,8 @@ namespace cv { namespace gpu { namespace mathfunc
         threads = dim3(threads_x, threads_y);
         grid = dim3(divUp(cols, threads.x * threads.y), 
                     divUp(rows, threads.y * threads.x));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -1044,7 +1033,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
         sumInSmem<nthreads, R>(smem, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1125,7 +1114,7 @@ namespace cv { namespace gpu { namespace mathfunc
         sumInSmem<nthreads, R>(smem, tid);
         sumInSmem<nthreads, R>(smem + nthreads, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1232,7 +1221,7 @@ namespace cv { namespace gpu { namespace mathfunc
         sumInSmem<nthreads, R>(smem + nthreads, tid);
         sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1349,7 +1338,7 @@ namespace cv { namespace gpu { namespace mathfunc
         sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
         sumInSmem<nthreads, R>(smem + 3 * nthreads, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1437,13 +1426,9 @@ namespace cv { namespace gpu { namespace mathfunc
         }
     }
 
-    } // namespace sum
-
-
     template <typename T>
     void sumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1515,7 +1500,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void sumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1565,7 +1549,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void absSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1637,7 +1620,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void absSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1687,7 +1669,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void sqrSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1759,7 +1740,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void sqrSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1804,301 +1784,305 @@ namespace cv { namespace gpu { namespace mathfunc
     template void sqrSumCaller<short>(const DevMem2Db, PtrStepb, double*, int);
     template void sqrSumCaller<int>(const DevMem2Db, PtrStepb, double*, int);
     template void sqrSumCaller<float>(const DevMem2Db, PtrStepb, double*, int);
+} // namespace sum
 
-    //////////////////////////////////////////////////////////////////////////////
-    // reduce
+//////////////////////////////////////////////////////////////////////////////
+// reduce
 
-    template <typename S> struct SumReductor
+template <typename S> struct SumReductor
+{
+    __device__ __forceinline__ S startValue() const
     {
-        __device__ __forceinline__ S startValue() const
-        {
-            return 0;
-        }
-
-        __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
-        {
-            return a + b;
-        }
+        return 0;
+    }
 
-        __device__ __forceinline__ S result(S r, double) const
-        {
-            return r;
-        }
-    };
+    __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
+    {
+        return a + b;
+    }
 
-    template <typename S> struct AvgReductor
+    __device__ __forceinline__ S result(S r, double) const
     {
-        __device__ __forceinline__ S startValue() const
-        {
-            return 0;
-        }
+        return r;
+    }
+};
 
-        __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
-        {
-            return a + b;
-        }
+template <typename S> struct AvgReductor
+{
+    __device__ __forceinline__ S startValue() const
+    {
+        return 0;
+    }
 
-        __device__ __forceinline__ double result(S r, double sz) const
-        {
-            return r / sz;
-        }
-    };
+    __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
+    {
+        return a + b;
+    }
 
-    template <typename S> struct MinReductor
+    __device__ __forceinline__ double result(S r, double sz) const
     {
-        __device__ __forceinline__ S startValue() const
-        {
-            return numeric_limits<S>::max();
-        }
+        return r / sz;
+    }
+};
 
-        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);
-        }
+template <typename S> struct MinReductor
+{
+    __device__ __forceinline__ S startValue() const
+    {
+        return numeric_limits<S>::max();
+    }
 
-        __device__ __forceinline__ S result(S r, double) const
-        {
-            return r;
-        }
-    };
+    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);
+    }
 
-    template <typename S> struct MaxReductor
+    __device__ __forceinline__ S result(S r, double) const
     {
-        __device__ __forceinline__ S startValue() const
-        {
-            return numeric_limits<S>::min();
-        }
+        return r;
+    }
+};
 
-        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);
-        }
+template <typename S> struct MaxReductor
+{
+    __device__ __forceinline__ S startValue() const
+    {
+        return numeric_limits<S>::min();
+    }
 
-        __device__ __forceinline__ S result(S r, double) const
-        {
-            return r;
-        }
-    };
+    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);
+    }
 
-    template <class Op, typename T, typename S, typename D> __global__ void reduceRows(const DevMem2D_<T> src, D* dst, const Op op)
+    __device__ __forceinline__ S result(S r, double) const
     {
-        __shared__ S smem[16 * 16];
+        return r;
+    }
+};
 
-        const int x = blockIdx.x * 16 + threadIdx.x;
+template <class Op, typename T, typename S, typename D> __global__ void reduceRows(const DevMem2D_<T> src, D* dst, const Op op)
+{
+    __shared__ S smem[16 * 16];
 
-        S myVal = op.startValue();
+    const int x = blockIdx.x * 16 + threadIdx.x;
 
-        if (x < src.cols)
-        {
-            for (int y = threadIdx.y; y < src.rows; y += 16)
-                myVal = op(myVal, src.ptr(y)[x]);
-        }        
+    S myVal = op.startValue();
 
-        smem[threadIdx.x * 16 + threadIdx.y] = myVal;
-        __syncthreads();
+    if (x < src.cols)
+    {
+        for (int y = threadIdx.y; y < src.rows; y += 16)
+            myVal = op(myVal, src.ptr(y)[x]);
+    }        
 
-        if (threadIdx.x < 8)
-        {
-            volatile S* srow = smem + threadIdx.y * 16;
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 8]);
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 4]);
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 2]);
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 1]);
-        }
-        __syncthreads();
+    smem[threadIdx.x * 16 + threadIdx.y] = myVal;
+    __syncthreads();
 
-        if (threadIdx.y == 0 && x < src.cols)
-            dst[x] = saturate_cast<D>(op.result(smem[threadIdx.x * 16], src.rows));
+    if (threadIdx.x < 8)
+    {
+        volatile S* srow = smem + threadIdx.y * 16;
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 8]);
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 4]);
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 2]);
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 1]);
     }
+    __syncthreads();
 
-    template <template <typename> class Op, typename T, typename S, typename D> void reduceRows_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
-    {
-        const dim3 block(16, 16);
-        const dim3 grid(divUp(src.cols, block.x));
+    if (threadIdx.y == 0 && x < src.cols)
+        dst[x] = saturate_cast<D>(op.result(smem[threadIdx.x * 16], src.rows));
+}
 
-        Op<S> op;
-        reduceRows<Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
-        cudaSafeCall( cudaGetLastError() );
+template <template <typename> class Op, typename T, typename S, typename D> void reduceRows_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
+{
+    const dim3 block(16, 16);
+    const dim3 grid(divUp(src.cols, block.x));
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+    Op<S> op;
+    reduceRows<Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
+    cudaSafeCall( cudaGetLastError() );
 
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+}
 
-    template <typename T, typename S, typename D> void reduceRows_gpu(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+template <typename T, typename S, typename D> void reduceRows_gpu(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
+        reduceRows_caller<SumReductor, T, S, D>, 
+        reduceRows_caller<AvgReductor, T, S, D>, 
+        reduceRows_caller<MaxReductor, T, S, D>, 
+        reduceRows_caller<MinReductor, T, S, D>
+    };
 
-        static const caller_t callers[] = 
-        {
-            reduceRows_caller<SumReductor, T, S, D>, 
-            reduceRows_caller<AvgReductor, T, S, D>, 
-            reduceRows_caller<MaxReductor, T, S, D>, 
-            reduceRows_caller<MinReductor, T, S, D>
-        };
+    callers[reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
+}
 
-        callers[reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
-    }
+template void reduceRows_gpu<uchar, int, uchar>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<uchar, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<uchar, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
 
-    template void reduceRows_gpu<uchar, int, uchar>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<uchar, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<uchar, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+template void reduceRows_gpu<ushort, int, ushort>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<ushort, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<ushort, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
 
-    template void reduceRows_gpu<ushort, int, ushort>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<ushort, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<ushort, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
+template void reduceRows_gpu<short, int, short>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<short, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<short, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
 
-    template void reduceRows_gpu<short, int, short>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<short, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<short, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
+template void reduceRows_gpu<int, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<int, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
 
-    template void reduceRows_gpu<int, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<int, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<float, float, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
 
-    template void reduceRows_gpu<float, float, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
 
 
+template <int cn, class Op, typename T, typename S, typename D> __global__ void reduceCols(const DevMem2D_<T> src, D* dst, const Op op)
+{
+    __shared__ S smem[256 * cn];
 
-    template <int cn, class Op, typename T, typename S, typename D> __global__ void reduceCols(const DevMem2D_<T> src, D* dst, const Op op)
-    {
-        __shared__ S smem[256 * cn];
+    const int y = blockIdx.x;
+
+    const T* src_row = src.ptr(y);
 
-        const int y = blockIdx.x;
+    S myVal[cn];
 
-        const T* src_row = src.ptr(y);
+    #pragma unroll
+    for (int c = 0; c < cn; ++c)
+        myVal[c] = op.startValue();
 
-        S myVal[cn];
+#if __CUDA_ARCH__ >= 200
 
+    // For cc >= 2.0 prefer L1 cache
+    for (int x = threadIdx.x; x < src.cols; x += 256)
+    {
         #pragma unroll
         for (int c = 0; c < cn; ++c)
-            myVal[c] = op.startValue();
+            myVal[c] = op(myVal[c], src_row[x * cn + c]);
+    }
 
-#if __CUDA_ARCH__ >= 200
+#else // __CUDA_ARCH__ >= 200
 
-        // For cc >= 2.0 prefer L1 cache
-        for (int x = threadIdx.x; x < src.cols; x += 256)
+    // For older arch use shared memory for cache
+    for (int x = 0; x < src.cols; x += 256)
+    {
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
         {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-                myVal[c] = op(myVal[c], src_row[x * cn + c]);
+            smem[c * 256 + threadIdx.x] = op.startValue();
+            const int load_x = x * cn + c * 256 + threadIdx.x;
+            if (load_x < src.cols * cn)
+                smem[c * 256 + threadIdx.x] = src_row[load_x];
         }
+        __syncthreads();
 
-#else // __CUDA_ARCH__ >= 200
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+            myVal[c] = op(myVal[c], smem[threadIdx.x * cn + c]);
+        __syncthreads();
+    }
 
-        // 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)
-            {
-                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();
+#endif // __CUDA_ARCH__ >= 200
 
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-                myVal[c] = op(myVal[c], smem[threadIdx.x * cn + c]);
-            __syncthreads();
-        }
+    #pragma unroll
+    for (int c = 0; c < cn; ++c)
+        smem[c * 256 + threadIdx.x] = myVal[c];
+    __syncthreads();
 
-#endif // __CUDA_ARCH__ >= 200
+    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] = myVal[c];
-        __syncthreads();
+            smem[c * 256 + threadIdx.x] = op(smem[c * 256 + threadIdx.x], smem[c * 256 + threadIdx.x + 64]);
+    }
+    __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();
+    volatile S* sdata = smem;
 
-        if (threadIdx.x < 64)
+    if (threadIdx.x < 32)
+    {
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
         {
-            #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]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 32]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 16]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 8]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 4]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 2]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 1]);
         }
-        __syncthreads();
+    }
+    __syncthreads();
 
-        volatile S* sdata = smem;
+    if (threadIdx.x < cn)
+        dst[y * cn + threadIdx.x] = saturate_cast<D>(op.result(smem[threadIdx.x * 256], src.cols));
+}
 
-        if (threadIdx.x < 32)
-        {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-            {
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 32]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 16]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 8]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 4]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 2]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 1]);
-            }
-        }
-        __syncthreads();
-
-        if (threadIdx.x < cn)
-            dst[y * cn + threadIdx.x] = saturate_cast<D>(op.result(smem[threadIdx.x * 256], src.cols));
-    }
+template <int cn, template <typename> class Op, typename T, typename S, typename D> void reduceCols_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
+{
+    const dim3 block(256);
+    const dim3 grid(src.rows);
 
-    template <int cn, template <typename> class Op, typename T, typename S, typename D> void reduceCols_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
-    {
-        const dim3 block(256);
-        const dim3 grid(src.rows);
+    Op<S> op;
+    reduceCols<cn, Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
+    cudaSafeCall( cudaGetLastError() );
 
-        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() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    }
+template <typename T, typename S, typename D> void reduceCols_gpu(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
 
-    template <typename T, typename S, typename D> void reduceCols_gpu(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+    static const caller_t callers[4][4] = 
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
+        {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>},
+    };
 
-        static const caller_t callers[4][4] = 
-        {
-            {reduceCols_caller<1, SumReductor, T, S, D>, reduceCols_caller<1, AvgReductor, T, S, D>, reduceCols_caller<1, MaxReductor, T, S, D>, reduceCols_caller<1, MinReductor, T, S, D>},
-            {reduceCols_caller<2, SumReductor, T, S, D>, reduceCols_caller<2, AvgReductor, T, S, D>, reduceCols_caller<2, MaxReductor, T, S, D>, reduceCols_caller<2, MinReductor, T, S, D>},
-            {reduceCols_caller<3, SumReductor, T, S, D>, reduceCols_caller<3, AvgReductor, T, S, D>, reduceCols_caller<3, MaxReductor, T, S, D>, reduceCols_caller<3, MinReductor, T, S, D>},
-            {reduceCols_caller<4, SumReductor, T, S, D>, reduceCols_caller<4, AvgReductor, T, S, D>, reduceCols_caller<4, MaxReductor, T, S, D>, reduceCols_caller<4, MinReductor, T, S, D>},
-        };
+    callers[cn - 1][reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
+}
 
-        callers[cn - 1][reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
-    }
+template void reduceCols_gpu<uchar, int, uchar>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceCols_gpu<uchar, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceCols_gpu<uchar, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+template void reduceCols_gpu<ushort, int, ushort>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
+template void reduceCols_gpu<ushort, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
+template void reduceCols_gpu<ushort, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
 
-    template void reduceCols_gpu<uchar, int, uchar>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceCols_gpu<uchar, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceCols_gpu<uchar, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceCols_gpu<short, int, short>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+template void reduceCols_gpu<short, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
+template void reduceCols_gpu<short, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
 
-    template void reduceCols_gpu<ushort, int, ushort>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
-    template void reduceCols_gpu<ushort, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
-    template void reduceCols_gpu<ushort, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceCols_gpu<int, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
+template void reduceCols_gpu<int, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
 
-    template void reduceCols_gpu<short, int, short>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
-    template void reduceCols_gpu<short, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
-    template void reduceCols_gpu<short, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+template void reduceCols_gpu<float, float, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
 
-    template void reduceCols_gpu<int, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
-    template void reduceCols_gpu<int, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+} // namespace mattrix_reductions
 
-    template void reduceCols_gpu<float, float, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
- }}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/pyr_down.cu b/modules/gpu/src/cuda/pyr_down.cu
index 385df7a5bda638e038b7bd04c69e20201fb3b509..7c5077e293a5ac853286dbcfeed0081fae5291e9 100644
--- a/modules/gpu/src/cuda/pyr_down.cu
+++ b/modules/gpu/src/cuda/pyr_down.cu
@@ -46,140 +46,142 @@
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace pyr_down {
+
+template <typename T, typename B> __global__ void pyrDown(const PtrStep<T> src, PtrStep<T> dst, const B b, int dst_cols)
 {
-    template <typename T, typename B> __global__ void pyrDown(const PtrStep<T> src, PtrStep<T> dst, const B b, int dst_cols)
-    {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y;
+
+    __shared__ value_type smem[256 + 4];
+
+    value_type sum;
+    
+    const int src_y = 2*y;
+
+    sum = VecTraits<value_type>::all(0);
+    
+    sum = sum + 0.0625f * b.at(src_y - 2, x, src.data, src.step);
+    sum = sum + 0.25f   * b.at(src_y - 1, x, src.data, src.step);
+    sum = sum + 0.375f  * b.at(src_y    , x, src.data, src.step);
+    sum = sum + 0.25f   * b.at(src_y + 1, x, src.data, src.step);
+    sum = sum + 0.0625f * b.at(src_y + 2, x, src.data, src.step);
+
+    smem[2 + threadIdx.x] = sum;
 
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y;
+    if (threadIdx.x < 2)
+    {
+        const int left_x = x - 2 + threadIdx.x;
 
-        __shared__ value_type smem[256 + 4];
+        sum = VecTraits<value_type>::all(0);
+    
+        sum = sum + 0.0625f * b.at(src_y - 2, left_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y - 1, left_x, src.data, src.step);
+        sum = sum + 0.375f  * b.at(src_y    , left_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y + 1, left_x, src.data, src.step);
+        sum = sum + 0.0625f * b.at(src_y + 2, left_x, src.data, src.step);
+
+        smem[threadIdx.x] = sum;
+    }
 
-        value_type sum;
-        
-        const int src_y = 2*y;
+    if (threadIdx.x > 253)
+    {
+        const int right_x = x + threadIdx.x + 2;
 
         sum = VecTraits<value_type>::all(0);
-        
-        sum = sum + 0.0625f * b.at(src_y - 2, x, src.data, src.step);
-        sum = sum + 0.25f   * b.at(src_y - 1, x, src.data, src.step);
-        sum = sum + 0.375f  * b.at(src_y    , x, src.data, src.step);
-        sum = sum + 0.25f   * b.at(src_y + 1, x, src.data, src.step);
-        sum = sum + 0.0625f * b.at(src_y + 2, x, src.data, src.step);
-
-        smem[2 + threadIdx.x] = sum;
-
-        if (threadIdx.x < 2)
-        {
-            const int left_x = x - 2 + threadIdx.x;
-
-            sum = VecTraits<value_type>::all(0);
-        
-            sum = sum + 0.0625f * b.at(src_y - 2, left_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y - 1, left_x, src.data, src.step);
-            sum = sum + 0.375f  * b.at(src_y    , left_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y + 1, left_x, src.data, src.step);
-            sum = sum + 0.0625f * b.at(src_y + 2, left_x, src.data, src.step);
-
-            smem[threadIdx.x] = sum;
-        }
-
-        if (threadIdx.x > 253)
-        {
-            const int right_x = x + threadIdx.x + 2;
-
-            sum = VecTraits<value_type>::all(0);
-        
-            sum = sum + 0.0625f * b.at(src_y - 2, right_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y - 1, right_x, src.data, src.step);
-            sum = sum + 0.375f  * b.at(src_y    , right_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y + 1, right_x, src.data, src.step);
-            sum = sum + 0.0625f * b.at(src_y + 2, right_x, src.data, src.step);
-
-            smem[4 + threadIdx.x] = sum;
-        }
-
-        __syncthreads();
-
-        if (threadIdx.x < 128)
-        {
-            const int tid2 = threadIdx.x * 2;
-
-            sum = VecTraits<value_type>::all(0);
-
-            sum = sum + 0.0625f * smem[2 + tid2 - 2];
-            sum = sum + 0.25f   * smem[2 + tid2 - 1];
-            sum = sum + 0.375f  * smem[2 + tid2    ];
-            sum = sum + 0.25f   * smem[2 + tid2 + 1];
-            sum = sum + 0.0625f * smem[2 + tid2 + 2];
-
-            const int dst_x = (blockIdx.x * blockDim.x + tid2) / 2;
-
-            if (dst_x < dst_cols)
-                dst.ptr(y)[dst_x] = saturate_cast<T>(sum);
-        }
+    
+        sum = sum + 0.0625f * b.at(src_y - 2, right_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y - 1, right_x, src.data, src.step);
+        sum = sum + 0.375f  * b.at(src_y    , right_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y + 1, right_x, src.data, src.step);
+        sum = sum + 0.0625f * b.at(src_y + 2, right_x, src.data, src.step);
+
+        smem[4 + threadIdx.x] = sum;
     }
 
-    template <typename T, template <typename> class B> void pyrDown_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+    __syncthreads();
+
+    if (threadIdx.x < 128)
     {
-        const dim3 block(256);
-        const dim3 grid(divUp(src.cols, block.x), dst.rows);
+        const int tid2 = threadIdx.x * 2;
+
+        sum = VecTraits<value_type>::all(0);
 
-        B<T> b(src.rows, src.cols);
+        sum = sum + 0.0625f * smem[2 + tid2 - 2];
+        sum = sum + 0.25f   * smem[2 + tid2 - 1];
+        sum = sum + 0.375f  * smem[2 + tid2    ];
+        sum = sum + 0.25f   * smem[2 + tid2 + 1];
+        sum = sum + 0.0625f * smem[2 + tid2 + 2];
 
-        pyrDown<T><<<grid, block, 0, stream>>>(src, dst, b, dst.cols);
-        cudaSafeCall( cudaGetLastError() );
+        const int dst_x = (blockIdx.x * blockDim.x + tid2) / 2;
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        if (dst_x < dst_cols)
+            dst.ptr(y)[dst_x] = saturate_cast<T>(sum);
     }
+}
 
-    template <typename T, int cn> void pyrDown_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
+template <typename T, template <typename> class B> void pyrDown_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    const dim3 block(256);
+    const dim3 grid(divUp(src.cols, block.x), dst.rows);
+
+    B<T> b(src.rows, src.cols);
+
+    pyrDown<T><<<grid, block, 0, stream>>>(src, dst, b, dst.cols);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template <typename T, int cn> void pyrDown_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
+{
+    typedef typename TypeVec<T, cn>::vec_type type;
+
+    typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
     {
-        typedef typename TypeVec<T, cn>::vec_type type;
+        pyrDown_caller<type, BrdReflect101>, pyrDown_caller<type, BrdReplicate>, pyrDown_caller<type, BrdConstant>, pyrDown_caller<type, BrdReflect>, pyrDown_caller<type, BrdWrap>
+    };
 
-        typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+    callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
+}
 
-        static const caller_t callers[] = 
-        {
-            pyrDown_caller<type, BrdReflect101>, pyrDown_caller<type, BrdReplicate>, pyrDown_caller<type, BrdConstant>, pyrDown_caller<type, BrdReflect>, pyrDown_caller<type, BrdWrap>
-        };
+template void pyrDown_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
-    }
+template void pyrDown_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+} // namespace pyr_down
 
-    template void pyrDown_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrDown_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrDown_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrDown_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrDown_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrDown_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/pyr_up.cu b/modules/gpu/src/cuda/pyr_up.cu
index 3555b89da4256a9dc95b2129985c21da87d58a71..35ddb3a865c05c39f93abd7a580e608fb999f2b8 100644
--- a/modules/gpu/src/cuda/pyr_up.cu
+++ b/modules/gpu/src/cuda/pyr_up.cu
@@ -46,135 +46,137 @@
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace pyr_up {
+
+template <typename T, typename B> __global__ void pyrUp(const PtrStep<T> src, DevMem2D_<T> dst, const B b)
 {
-    template <typename T, typename B> __global__ void pyrUp(const PtrStep<T> src, DevMem2D_<T> dst, const B b)
-    {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    __shared__ T smem1[10][10];
+    __shared__ value_type smem2[20][16];
 
-        __shared__ T smem1[10][10];
-        __shared__ value_type smem2[20][16];
+    value_type sum;
 
-        value_type sum;
+    if (threadIdx.x < 10 && threadIdx.y < 10)
+        smem1[threadIdx.y][threadIdx.x] = b.at(blockIdx.y * blockDim.y / 2 + threadIdx.y - 1, blockIdx.x * blockDim.x / 2 + threadIdx.x - 1, src.data, src.step);
 
-        if (threadIdx.x < 10 && threadIdx.y < 10)
-            smem1[threadIdx.y][threadIdx.x] = b.at(blockIdx.y * blockDim.y / 2 + threadIdx.y - 1, blockIdx.x * blockDim.x / 2 + threadIdx.x - 1, src.data, src.step);
+    __syncthreads();
 
-        __syncthreads();
+    const int tidx = threadIdx.x;
 
-        const int tidx = threadIdx.x;
+    sum = VecTraits<value_type>::all(0);
 
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx - 2) >> 1)];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx - 1) >> 1)];
+    sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[1 + threadIdx.y / 2][1 + ((tidx    ) >> 1)];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx + 1) >> 1)];
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx + 2) >> 1)];
+
+    smem2[2 + threadIdx.y][tidx] = sum;
+
+    if (threadIdx.y < 2)
+    {
         sum = VecTraits<value_type>::all(0);
 
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx - 2) >> 1)];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx - 1) >> 1)];
-        sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[1 + threadIdx.y / 2][1 + ((tidx    ) >> 1)];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx + 1) >> 1)];
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx + 2) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx - 2) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx - 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[0][1 + ((tidx    ) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx + 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx + 2) >> 1)];
 
-        smem2[2 + threadIdx.y][tidx] = sum;
+        smem2[threadIdx.y][tidx] = sum;
+    }
 
-        if (threadIdx.y < 2)
-        {
-            sum = VecTraits<value_type>::all(0);
+    if (threadIdx.y > 13)
+    {
+        sum = VecTraits<value_type>::all(0);
 
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx - 2) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx - 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[0][1 + ((tidx    ) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx + 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx + 2) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx - 2) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx - 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[9][1 + ((tidx    ) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx + 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx + 2) >> 1)];
 
-            smem2[threadIdx.y][tidx] = sum;
-        }
+        smem2[4 + threadIdx.y][tidx] = sum;
+    }
 
-        if (threadIdx.y > 13)
-        {
-            sum = VecTraits<value_type>::all(0);
+    __syncthreads();
 
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx - 2) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx - 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[9][1 + ((tidx    ) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx + 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx + 2) >> 1)];
+    sum = VecTraits<value_type>::all(0);
 
-            smem2[4 + threadIdx.y][tidx] = sum;
-        }
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y - 2][tidx];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y - 1][tidx];
+    sum = sum + (tidx % 2 == 0) * 0.375f  * smem2[2 + threadIdx.y    ][tidx];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y + 1][tidx];
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y + 2][tidx];
 
-        __syncthreads();
+    if (x < dst.cols && y < dst.rows)
+        dst.ptr(y)[x] = saturate_cast<T>(4.0f * sum);
+}
 
-        sum = VecTraits<value_type>::all(0);
+template <typename T, template <typename> class B> void pyrUp_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    const dim3 block(16, 16);
+    const dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y - 2][tidx];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y - 1][tidx];
-        sum = sum + (tidx % 2 == 0) * 0.375f  * smem2[2 + threadIdx.y    ][tidx];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y + 1][tidx];
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y + 2][tidx];
+    B<T> b(src.rows, src.cols);
 
-        if (x < dst.cols && y < dst.rows)
-            dst.ptr(y)[x] = saturate_cast<T>(4.0f * sum);
-    }
+    pyrUp<T><<<grid, block, 0, stream>>>(src, dst, b);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template <typename T, int cn> void pyrUp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
+{
+    typedef typename TypeVec<T, cn>::vec_type type;
 
-    template <typename T, template <typename> class B> void pyrUp_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+    typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
     {
-        const dim3 block(16, 16);
-        const dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        pyrUp_caller<type, BrdReflect101>, pyrUp_caller<type, BrdReplicate>, pyrUp_caller<type, BrdConstant>, pyrUp_caller<type, BrdReflect>, pyrUp_caller<type, BrdWrap>
+    };
 
-        B<T> b(src.rows, src.cols);
+    callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
+}
 
-        pyrUp<T><<<grid, block, 0, stream>>>(src, dst, b);
-        cudaSafeCall( cudaGetLastError() );
+template void pyrUp_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+template void pyrUp_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-    template <typename T, int cn> void pyrUp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
-    {
-        typedef typename TypeVec<T, cn>::vec_type type;
+template void pyrUp_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+template void pyrUp_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        static const caller_t callers[] = 
-        {
-            pyrUp_caller<type, BrdReflect101>, pyrUp_caller<type, BrdReplicate>, pyrUp_caller<type, BrdConstant>, pyrUp_caller<type, BrdReflect>, pyrUp_caller<type, BrdWrap>
-        };
+template void pyrUp_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
-    }
+template void pyrUp_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+} // namespace pyr_up
 
-    template void pyrUp_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/remap.cu b/modules/gpu/src/cuda/remap.cu
index 2f5f3cf94fa0da3b74e91baee3e30ac6ab2163b2..0fda25e884ad7036557d2eff009f833a176dbd71 100644
--- a/modules/gpu/src/cuda/remap.cu
+++ b/modules/gpu/src/cuda/remap.cu
@@ -47,64 +47,62 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/filters.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
-{
+namespace remap {
     
-    template <typename Ptr2D, typename T> __global__ void remap(const Ptr2D src, const PtrStepf mapx, const PtrStepf mapy, DevMem2D_<T> dst)
-    {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+template <typename Ptr2D, typename T> __global__ void remap(const Ptr2D src, const PtrStepf mapx, const PtrStepf mapy, DevMem2D_<T> dst)
+{
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-        if (x < dst.cols && y < dst.rows)
-        {
-            const float xcoo = mapx.ptr(y)[x];
-            const float ycoo = mapy.ptr(y)[x];
+    if (x < dst.cols && y < dst.rows)
+    {
+        const float xcoo = mapx.ptr(y)[x];
+        const float ycoo = mapy.ptr(y)[x];
 
-            dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
-        }
+        dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
     }
+}
 
-    template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherStream
+template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherStream
+{
+    static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
+        const float* borderValue, cudaStream_t stream, int)
     {
-        static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
-            const float* borderValue, cudaStream_t stream, int)
-        {
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
-            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
-
-            B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
-            BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
-
-            remap<<<grid, block, 0, stream>>>(filter_src, mapx, mapy, dst);
-            cudaSafeCall( cudaGetLastError() );
-        }
-    };
-    
-    template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherNonStream
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
+        
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+
+        B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
+        BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
+
+        remap<<<grid, block, 0, stream>>>(filter_src, mapx, mapy, dst);
+        cudaSafeCall( cudaGetLastError() );
+    }
+};
+
+template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherNonStream
+{
+    static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, const float* borderValue, int)
     {
-        static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, const float* borderValue, int)
-        {
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
-            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
+        
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
-            BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
+        B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
+        BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
 
-            remap<<<grid, block>>>(filter_src, mapx, mapy, dst);
-            cudaSafeCall( cudaGetLastError() );
+        remap<<<grid, block>>>(filter_src, mapx, mapy, dst);
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
 
 #define OPENCV_GPU_IMPLEMENT_REMAP_TEX(type) \
     texture< type , cudaTextureType2D> tex_remap_ ## type (0, cudaFilterModePoint, cudaAddressModeClamp); \
@@ -124,7 +122,7 @@ namespace cv { namespace gpu { namespace imgproc
             typedef typename TypeVec<float, VecTraits< type >::cn>::vec_type work_type; \
             dim3 block(32, cc >= 20 ? 8 : 4); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_remap_ ## type , src); \
+            bindTexture(&tex_remap_ ## type , src); \
             tex_remap_ ## type ##_reader texSrc; \
             B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue)); \
             BorderReader< tex_remap_ ## type ##_reader, B<work_type> > brdSrc(texSrc, brd); \
@@ -140,7 +138,7 @@ namespace cv { namespace gpu { namespace imgproc
         { \
             dim3 block(32, 8); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_remap_ ## type , src); \
+            bindTexture(&tex_remap_ ## type , src); \
             tex_remap_ ## type ##_reader texSrc; \
             Filter< tex_remap_ ## type ##_reader > filter_src(texSrc); \
             remap<<<grid, block>>>(filter_src, mapx, mapy, dst); \
@@ -149,105 +147,108 @@ namespace cv { namespace gpu { namespace imgproc
         } \
     };
     
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar4)
-    
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(schar)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(char2)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(char4)
-    
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort4)
-    
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(short)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(short2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(short4)
-    
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(int)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(int2)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(int4)
-    
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(float)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(float2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(float4)
-    
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar4)
+
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(schar)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(char2)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(char4)
+
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort4)
+
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(short)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(short2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(short4)
+
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(int)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(int2)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(int4)
+
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(float)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(float2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(float4)
+
 #undef OPENCV_GPU_IMPLEMENT_REMAP_TEX
 
-    template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcher
-    { 
-        static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
-            const float* borderValue, cudaStream_t stream, int cc)
-        {
-            if (stream == 0)
-                RemapDispatcherNonStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, cc);
-            else
-                RemapDispatcherStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, stream, cc);
+template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcher
+{ 
+    static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
+        const float* borderValue, cudaStream_t stream, int cc)
+    {
+        if (stream == 0)
+            RemapDispatcherNonStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, cc);
+        else
+            RemapDispatcherStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, stream, cc);
+    }
+};
+
+template <typename T> void remap_gpu(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, 
+    int borderMode, const float* borderValue, cudaStream_t stream, int cc)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2D_<T>& dst, 
+        const float* borderValue, cudaStream_t stream, int cc);
+
+    static const caller_t callers[3][5] = 
+    {
+        { 
+            RemapDispatcher<PointFilter, BrdReflect101, T>::call, 
+            RemapDispatcher<PointFilter, BrdReplicate, T>::call, 
+            RemapDispatcher<PointFilter, BrdConstant, T>::call, 
+            RemapDispatcher<PointFilter, BrdReflect, T>::call, 
+            RemapDispatcher<PointFilter, BrdWrap, T>::call 
+        },
+        { 
+            RemapDispatcher<LinearFilter, BrdReflect101, T>::call, 
+            RemapDispatcher<LinearFilter, BrdReplicate, T>::call, 
+            RemapDispatcher<LinearFilter, BrdConstant, T>::call, 
+            RemapDispatcher<LinearFilter, BrdReflect, T>::call, 
+            RemapDispatcher<LinearFilter, BrdWrap, T>::call 
+        },
+        { 
+            RemapDispatcher<CubicFilter, BrdReflect101, T>::call, 
+            RemapDispatcher<CubicFilter, BrdReplicate, T>::call, 
+            RemapDispatcher<CubicFilter, BrdConstant, T>::call, 
+            RemapDispatcher<CubicFilter, BrdReflect, T>::call, 
+            RemapDispatcher<CubicFilter, BrdWrap, T>::call 
         }
     };
 
-    template <typename T> void remap_gpu(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, 
-        int borderMode, const float* borderValue, cudaStream_t stream, int cc)
-    {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2D_<T>& dst, 
-            const float* borderValue, cudaStream_t stream, int cc);
-
-        static const caller_t callers[3][5] = 
-        {
-            { 
-                RemapDispatcher<PointFilter, BrdReflect101, T>::call, 
-                RemapDispatcher<PointFilter, BrdReplicate, T>::call, 
-                RemapDispatcher<PointFilter, BrdConstant, T>::call, 
-                RemapDispatcher<PointFilter, BrdReflect, T>::call, 
-                RemapDispatcher<PointFilter, BrdWrap, T>::call 
-            },
-            { 
-                RemapDispatcher<LinearFilter, BrdReflect101, T>::call, 
-                RemapDispatcher<LinearFilter, BrdReplicate, T>::call, 
-                RemapDispatcher<LinearFilter, BrdConstant, T>::call, 
-                RemapDispatcher<LinearFilter, BrdReflect, T>::call, 
-                RemapDispatcher<LinearFilter, BrdWrap, T>::call 
-            },
-            { 
-                RemapDispatcher<CubicFilter, BrdReflect101, T>::call, 
-                RemapDispatcher<CubicFilter, BrdReplicate, T>::call, 
-                RemapDispatcher<CubicFilter, BrdConstant, T>::call, 
-                RemapDispatcher<CubicFilter, BrdReflect, T>::call, 
-                RemapDispatcher<CubicFilter, BrdWrap, T>::call 
-            }
-        };
-
-        callers[interpolation][borderMode](static_cast< DevMem2D_<T> >(src), xmap, ymap, static_cast< DevMem2D_<T> >(dst), borderValue, stream, cc);
-    }
+    callers[interpolation][borderMode](static_cast< DevMem2D_<T> >(src), xmap, ymap, static_cast< DevMem2D_<T> >(dst), borderValue, stream, cc);
+}
 
-    template void remap_gpu<uchar >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<uchar2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<uchar3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<uchar4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    //template void remap_gpu<schar>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<char2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<char3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<char4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    template void remap_gpu<ushort >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<ushort2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<ushort3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<ushort4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    template void remap_gpu<short >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<short2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<short3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<short4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    //template void remap_gpu<int >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<int2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<int3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<int4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    template void remap_gpu<float >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<float2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<float3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<float4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-}}}
+template void remap_gpu<uchar >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<uchar2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<uchar3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<uchar4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+//template void remap_gpu<schar>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<char2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<char3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<char4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+template void remap_gpu<ushort >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<ushort2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<ushort3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<ushort4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+template void remap_gpu<short >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<short2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<short3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<short4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+//template void remap_gpu<int >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<int2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<int3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<int4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+template void remap_gpu<float >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<float2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<float3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<float4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+} // namespace remap
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/resize.cu b/modules/gpu/src/cuda/resize.cu
index 78871f750e5f5fba897c17a7a7f152e8f71ee3f0..b79716282b5e5e887c7e9d8f759bcacee15af7b0 100644
--- a/modules/gpu/src/cuda/resize.cu
+++ b/modules/gpu/src/cuda/resize.cu
@@ -47,102 +47,100 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/filters.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
-{
+namespace resize {
     
-    template <typename Ptr2D, typename T> __global__ void resize(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
-    {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+template <typename Ptr2D, typename T> __global__ void resize(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
+{
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-        if (x < dst.cols && y < dst.rows)
-        {
-            const float xcoo = x / fx;
-            const float ycoo = y / fy;
+    if (x < dst.cols && y < dst.rows)
+    {
+        const float xcoo = x / fx;
+        const float ycoo = y / fy;
 
-            dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
-        }
+        dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
     }
-    template <typename Ptr2D, typename T> __global__ void resizeNN(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
+}
+template <typename Ptr2D, typename T> __global__ void resizeNN(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
+{
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < dst.cols && y < dst.rows)
     {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        const float xcoo = x / fx;
+        const float ycoo = y / fy;
+
+        dst.ptr(y)[x] = src(__float2int_rd(ycoo), __float2int_rd(xcoo));
+    }
+}
+
+template <template <typename> class Filter, typename T> struct ResizeDispatcherStream
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-        if (x < dst.cols && y < dst.rows)
-        {
-            const float xcoo = x / fx;
-            const float ycoo = y / fy;
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
 
-            dst.ptr(y)[x] = src(__float2int_rd(ycoo), __float2int_rd(xcoo));
-        }
+        resize<<<grid, block, 0, stream>>>(filter_src, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
     }
+};
+template <typename T> struct ResizeDispatcherStream<PointFilter, T>
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-    template <template <typename> class Filter, typename T> struct ResizeDispatcherStream
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
-
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
-
-            resize<<<grid, block, 0, stream>>>(filter_src, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
-        }
-    };
-    template <typename T> struct ResizeDispatcherStream<PointFilter, T>
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        resizeNN<<<grid, block, 0, stream>>>(brdSrc, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
+    }
+};
 
-            resizeNN<<<grid, block, 0, stream>>>(brdSrc, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
-        }
-    };
-    
-    template <template <typename> class Filter, typename T> struct ResizeDispatcherNonStream
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+template <template <typename> class Filter, typename T> struct ResizeDispatcherNonStream
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
 
-            resize<<<grid, block>>>(filter_src, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
+        resize<<<grid, block>>>(filter_src, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template <typename T> struct ResizeDispatcherNonStream<PointFilter, T>
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
+template <typename T> struct ResizeDispatcherNonStream<PointFilter, T>
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
 
-            resizeNN<<<grid, block>>>(brdSrc, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
+        resizeNN<<<grid, block>>>(brdSrc, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
 
 #define OPENCV_GPU_IMPLEMENT_RESIZE_TEX(type) \
     texture< type , cudaTextureType2D> tex_resize_ ## type (0, cudaFilterModePoint, cudaAddressModeClamp); \
@@ -161,7 +159,7 @@ namespace cv { namespace gpu { namespace imgproc
         { \
             dim3 block(32, 8); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_resize_ ## type , src); \
+            bindTexture(&tex_resize_ ## type , src); \
             tex_resize_ ## type ##_reader texSrc; \
             Filter< tex_resize_ ## type ##_reader > filter_src(texSrc); \
             resize<<<grid, block>>>(filter_src, fx, fy, dst); \
@@ -175,7 +173,7 @@ namespace cv { namespace gpu { namespace imgproc
         { \
             dim3 block(32, 8); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_resize_ ## type , src); \
+            bindTexture(&tex_resize_ ## type , src); \
             tex_resize_ ## type ##_reader texSrc; \
             resizeNN<<<grid, block>>>(texSrc, fx, fy, dst); \
             cudaSafeCall( cudaGetLastError() ); \
@@ -183,82 +181,85 @@ namespace cv { namespace gpu { namespace imgproc
         } \
     };
     
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar4)
-    
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(schar)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char2)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char4)
-    
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort4)
-    
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short4)
-    
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int2)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int4)
-    
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float4)
-    
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar4)
+
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(schar)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char2)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char4)
+
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort4)
+
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short4)
+
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int2)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int4)
+
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float4)
+
 #undef OPENCV_GPU_IMPLEMENT_RESIZE_TEX
 
-    template <template <typename> class Filter, typename T> struct ResizeDispatcher
-    { 
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
-        {
-            if (stream == 0)
-                ResizeDispatcherNonStream<Filter, T>::call(src, fx, fy, dst);
-            else
-                ResizeDispatcherStream<Filter, T>::call(src, fx, fy, dst, stream);
-        }
-    };
+template <template <typename> class Filter, typename T> struct ResizeDispatcher
+{ 
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {
+        if (stream == 0)
+            ResizeDispatcherNonStream<Filter, T>::call(src, fx, fy, dst);
+        else
+            ResizeDispatcherStream<Filter, T>::call(src, fx, fy, dst, stream);
+    }
+};
+
+template <typename T> void resize_gpu(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream);
 
-    template <typename T> void resize_gpu(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream)
+    static const caller_t callers[3] = 
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream);
+        ResizeDispatcher<PointFilter, T>::call, ResizeDispatcher<LinearFilter, T>::call, ResizeDispatcher<CubicFilter, T>::call
+    };
 
-        static const caller_t callers[3] = 
-        {
-            ResizeDispatcher<PointFilter, T>::call, ResizeDispatcher<LinearFilter, T>::call, ResizeDispatcher<CubicFilter, T>::call
-        };
+    callers[interpolation](static_cast< DevMem2D_<T> >(src), fx, fy, static_cast< DevMem2D_<T> >(dst), stream);
+}
 
-        callers[interpolation](static_cast< DevMem2D_<T> >(src), fx, fy, static_cast< DevMem2D_<T> >(dst), stream);
-    }
+template void resize_gpu<uchar >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<uchar2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<uchar3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<uchar4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
 
-    template void resize_gpu<uchar >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<uchar2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<uchar3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<uchar4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    //template void resize_gpu<schar>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<char2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<char3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<char4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    template void resize_gpu<ushort >(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<ushort2>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<ushort3>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<ushort4>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    template void resize_gpu<short >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<short2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<short3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<short4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    //template void resize_gpu<int >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<int2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<int3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<int4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    template void resize_gpu<float >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<float2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<float3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<float4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-}}}
+//template void resize_gpu<schar>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<char2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<char3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<char4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+template void resize_gpu<ushort >(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<ushort2>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<ushort3>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<ushort4>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+template void resize_gpu<short >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<short2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<short3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<short4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+//template void resize_gpu<int >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<int2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<int3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<int4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+template void resize_gpu<float >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<float2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<float3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<float4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+} // namespace resize
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/row_filter.cu b/modules/gpu/src/cuda/row_filter.cu
index cdcee7a28bfddf86c8c11d2597077981ba901759..e185669e0ef5cd740328b8b8ae890cae9825af35 100644
--- a/modules/gpu/src/cuda/row_filter.cu
+++ b/modules/gpu/src/cuda/row_filter.cu
@@ -47,8 +47,7 @@
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
 #define MAX_KERNEL_SIZE 16
 #define BLOCK_DIM_X 16
@@ -56,218 +55,218 @@ using namespace cv::gpu::device;
 #define RESULT_STEPS 8
 #define HALO_STEPS 1
 
-namespace filter_row
+namespace row_filter {
+
+__constant__ float c_kernel[MAX_KERNEL_SIZE];
+
+void loadKernel(const float kernel[], int ksize)
 {
-    __constant__ float c_kernel[MAX_KERNEL_SIZE];
+    cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
+}
 
-    void loadKernel(const float kernel[], int ksize)
+namespace detail
+{
+    template <typename T, size_t size> struct SmemType
     {
-        cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
-    }
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type smem_t;
+    };
 
-    namespace detail
+    template <typename T> struct SmemType<T, 4>
     {
-        template <typename T, size_t size> struct SmemType
-        {
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type smem_t;
-        };
+        typedef T smem_t;
+    };
+}
 
-        template <typename T> struct SmemType<T, 4>
-        {
-            typedef T smem_t;
-        };
-    }
+template <typename T> struct SmemType
+{
+    typedef typename detail::SmemType<T, sizeof(T)>::smem_t smem_t;
+};
 
-    template <typename T> struct SmemType
-    {
-        typedef typename detail::SmemType<T, sizeof(T)>::smem_t smem_t;
-    };
+template <int KERNEL_SIZE, typename T, typename D, typename B>
+__global__ void linearRowFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
+{
+    typedef typename SmemType<T>::smem_t smem_t;
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
 
-    template <int KERNEL_SIZE, typename T, typename D, typename B>
-    __global__ void linearRowFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
-    {
-        typedef typename SmemType<T>::smem_t smem_t;
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+    __shared__ smem_t smem[BLOCK_DIM_Y][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_X];
 
-        __shared__ smem_t smem[BLOCK_DIM_Y][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_X];
+    //Offset to the left halo edge
+    const int x = (blockIdx.x * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_X + threadIdx.x;
+    const int y = blockIdx.y * BLOCK_DIM_Y + threadIdx.y;
 
-        //Offset to the left halo edge
-        const int x = (blockIdx.x * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_X + threadIdx.x;
-        const int y = blockIdx.y * BLOCK_DIM_Y + threadIdx.y;
+    if (y < src.rows)
+    {
+        const T* src_row = src.ptr(y);
 
-        if (y < src.rows)
-        {
-            const T* src_row = src.ptr(y);
+        //Load main data
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
+            smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
 
-            //Load main data
-            #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-                smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
+        //Load left halo
+        #pragma unroll
+        for(int i = 0; i < HALO_STEPS; ++i)
+            smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_low(i * BLOCK_DIM_X + x, src_row);
 
-            //Load left halo
-            #pragma unroll
-            for(int i = 0; i < HALO_STEPS; ++i)
-                smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_low(i * BLOCK_DIM_X + x, src_row);
+        //Load right halo
+        #pragma unroll
+        for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
+            smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
 
-            //Load right halo
-            #pragma unroll
-            for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
-                smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
+        __syncthreads();
 
-            __syncthreads();
+        D* dst_row = dst.ptr(y);
 
-            D* dst_row = dst.ptr(y);
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
+        {
+            sum_t sum = VecTraits<sum_t>::all(0);
 
             #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-            {
-                sum_t sum = VecTraits<sum_t>::all(0);
+            for (int j = 0; j < KERNEL_SIZE; ++j)
+                sum = sum + smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X + j - anchor] * c_kernel[j];
 
-                #pragma unroll
-                for (int j = 0; j < KERNEL_SIZE; ++j)
-                    sum = sum + smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X + j - anchor] * c_kernel[j];
+            int dstX = x + i * BLOCK_DIM_X;
 
-                int dstX = x + i * BLOCK_DIM_X;
-
-                if (dstX < src.cols)
-                    dst_row[dstX] = saturate_cast<D>(sum);
-            }
+            if (dstX < src.cols)
+                dst_row[dstX] = saturate_cast<D>(sum);
         }
     }
 }
 
-namespace cv { namespace gpu { namespace filters
+template <int ksize, typename T, typename D, template<typename> class B>
+void linearRowFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
 {
-    template <int ksize, typename T, typename D, template<typename> class B>
-    void linearRowFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
-    {
-        typedef typename filter_row::SmemType<T>::smem_t smem_t;
+    typedef typename SmemType<T>::smem_t smem_t;
 
-        const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
-        const dim3 grid(divUp(src.cols, RESULT_STEPS * BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y));
+    const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
+    const dim3 grid(divUp(src.cols, RESULT_STEPS * BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y));
 
-        B<smem_t> b(src.cols);
+    B<smem_t> b(src.cols);
 
-        filter_row::linearRowFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
-        cudaSafeCall( cudaGetLastError() );
+    linearRowFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <typename T, typename D>
-    void linearRowFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
+template <typename T, typename D>
+void linearRowFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
+    static const caller_t callers[5][17] = 
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
-        static const caller_t callers[5][17] = 
         {
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<2 , T, D, BrdRowReflect101>,
-                linearRowFilter_caller<3 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<4 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<5 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<6 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<7 , T, D, BrdRowReflect101>,
-                linearRowFilter_caller<8 , T, D, BrdRowReflect101>,
-                linearRowFilter_caller<9 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<10, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<11, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<12, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<13, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<14, T, D, BrdRowReflect101>,
-                linearRowFilter_caller<15, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<16, T, D, BrdRowReflect101>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<2 , T, D, BrdRowReplicate>,
-                linearRowFilter_caller<3 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<4 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<5 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<6 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<7 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<8 , T, D, BrdRowReplicate>,
-                linearRowFilter_caller<9 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<10, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<11, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<12, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<13, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<14, T, D, BrdRowReplicate>,
-                linearRowFilter_caller<15, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<16, T, D, BrdRowReplicate>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<2 , T, D, BrdRowConstant>,
-                linearRowFilter_caller<3 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<4 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<5 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<6 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<7 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<8 , T, D, BrdRowConstant>,
-                linearRowFilter_caller<9 , T, D, BrdRowConstant>,
-                linearRowFilter_caller<10, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<11, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<12, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<13, T, D, BrdRowConstant>,
-                linearRowFilter_caller<14, T, D, BrdRowConstant>,
-                linearRowFilter_caller<15, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<16, T, D, BrdRowConstant>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<2 , T, D, BrdRowReflect>,
-                linearRowFilter_caller<3 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<4 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<5 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<6 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<7 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<8 , T, D, BrdRowReflect>,
-                linearRowFilter_caller<9 , T, D, BrdRowReflect>,
-                linearRowFilter_caller<10, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<11, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<12, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<13, T, D, BrdRowReflect>,
-                linearRowFilter_caller<14, T, D, BrdRowReflect>,
-                linearRowFilter_caller<15, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<16, T, D, BrdRowReflect>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<2 , T, D, BrdRowWrap>,
-                linearRowFilter_caller<3 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<4 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<5 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<6 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<7 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<8 , T, D, BrdRowWrap>,
-                linearRowFilter_caller<9 , T, D, BrdRowWrap>,
-                linearRowFilter_caller<10, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<11, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<12, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<13, T, D, BrdRowWrap>,
-                linearRowFilter_caller<14, T, D, BrdRowWrap>,
-                linearRowFilter_caller<15, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<16, T, D, BrdRowWrap>
-            }
-        };
-        
-        filter_row::loadKernel(kernel, ksize);
-
-        callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
-    }
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<2 , T, D, BrdRowReflect101>,
+            linearRowFilter_caller<3 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<4 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<5 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<6 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<7 , T, D, BrdRowReflect101>,
+            linearRowFilter_caller<8 , T, D, BrdRowReflect101>,
+            linearRowFilter_caller<9 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<10, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<11, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<12, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<13, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<14, T, D, BrdRowReflect101>,
+            linearRowFilter_caller<15, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<16, T, D, BrdRowReflect101>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<2 , T, D, BrdRowReplicate>,
+            linearRowFilter_caller<3 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<4 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<5 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<6 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<7 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<8 , T, D, BrdRowReplicate>,
+            linearRowFilter_caller<9 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<10, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<11, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<12, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<13, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<14, T, D, BrdRowReplicate>,
+            linearRowFilter_caller<15, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<16, T, D, BrdRowReplicate>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<2 , T, D, BrdRowConstant>,
+            linearRowFilter_caller<3 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<4 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<5 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<6 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<7 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<8 , T, D, BrdRowConstant>,
+            linearRowFilter_caller<9 , T, D, BrdRowConstant>,
+            linearRowFilter_caller<10, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<11, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<12, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<13, T, D, BrdRowConstant>,
+            linearRowFilter_caller<14, T, D, BrdRowConstant>,
+            linearRowFilter_caller<15, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<16, T, D, BrdRowConstant>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<2 , T, D, BrdRowReflect>,
+            linearRowFilter_caller<3 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<4 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<5 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<6 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<7 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<8 , T, D, BrdRowReflect>,
+            linearRowFilter_caller<9 , T, D, BrdRowReflect>,
+            linearRowFilter_caller<10, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<11, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<12, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<13, T, D, BrdRowReflect>,
+            linearRowFilter_caller<14, T, D, BrdRowReflect>,
+            linearRowFilter_caller<15, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<16, T, D, BrdRowReflect>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<2 , T, D, BrdRowWrap>,
+            linearRowFilter_caller<3 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<4 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<5 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<6 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<7 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<8 , T, D, BrdRowWrap>,
+            linearRowFilter_caller<9 , T, D, BrdRowWrap>,
+            linearRowFilter_caller<10, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<11, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<12, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<13, T, D, BrdRowWrap>,
+            linearRowFilter_caller<14, T, D, BrdRowWrap>,
+            linearRowFilter_caller<15, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<16, T, D, BrdRowWrap>
+        }
+    };
+    
+    loadKernel(kernel, ksize);
+
+    callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
+}
+
+template void linearRowFilter_gpu<uchar , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<uchar4, float4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearRowFilter_gpu<short , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearRowFilter_gpu<short2, float2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<short3, float3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<int   , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+
+} // namespace row_filter
 
-    template void linearRowFilter_gpu<uchar , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<uchar4, float4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearRowFilter_gpu<short , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearRowFilter_gpu<short2, float2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<short3, float3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<int   , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/safe_call.hpp b/modules/gpu/src/cuda/safe_call.hpp
index 6a7d57729372d7a6cc2164a061cafea02ff73aaa..a3dc2f46aecf54ef0461ff2c1b5c05e513f55630 100644
--- a/modules/gpu/src/cuda/safe_call.hpp
+++ b/modules/gpu/src/cuda/safe_call.hpp
@@ -43,9 +43,9 @@
 #ifndef __OPENCV_CUDA_SAFE_CALL_HPP__
 #define __OPENCV_CUDA_SAFE_CALL_HPP__
 
-#include "cuda_runtime_api.h"
-#include "cufft.h"
-#include "cublas.h"
+#include <cuda_runtime_api.h>
+#include <cufft.h>
+#include <cublas.h>
 #include "NCV.hpp"
 
 #if defined(__GNUC__)
@@ -62,46 +62,44 @@
     #define cublasSafeCall(expr)  ___cublasSafeCall(expr, __FILE__, __LINE__)
 #endif
 
-namespace cv
-{
-    namespace gpu
-    {
-        void error(const char *error_string, const char *file, const int line, const char *func = "");
-        void nppError(int err, const char *file, const int line, const char *func = "");
-        void ncvError(int err, const char *file, const int line, const char *func = "");
-        void cufftError(int err, const char *file, const int line, const char *func = "");
-        void cublasError(int err, const char *file, const int line, const char *func = "");
+namespace cv { namespace gpu {
+
+void error(const char *error_string, const char *file, const int line, const char *func = "");
+void nppError(int err, const char *file, const int line, const char *func = "");
+void ncvError(int err, const char *file, const int line, const char *func = "");
+void cufftError(int err, const char *file, const int line, const char *func = "");
+void cublasError(int err, const char *file, const int line, const char *func = "");
 
-        static inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "")
-        {
-            if (cudaSuccess != err)
-                cv::gpu::error(cudaGetErrorString(err), file, line, func);
-        }
+static inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "")
+{
+    if (cudaSuccess != err)
+        cv::gpu::error(cudaGetErrorString(err), file, line, func);
+}
 
-        static inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
-        {
-            if (err < 0)
-                cv::gpu::nppError(err, file, line, func);
-        }
+static inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
+{
+    if (err < 0)
+        cv::gpu::nppError(err, file, line, func);
+}
 
-        static inline void ___ncvSafeCall(int err, const char *file, const int line, const char *func = "")
-        {
-            if (NCV_SUCCESS != err)
-                cv::gpu::ncvError(err, file, line, func);
-        }
+static inline void ___ncvSafeCall(int err, const char *file, const int line, const char *func = "")
+{
+    if (NCV_SUCCESS != err)
+        cv::gpu::ncvError(err, file, line, func);
+}
 
-        static inline void ___cufftSafeCall(cufftResult_t err, const char *file, const int line, const char *func = "")
-        {
-            if (CUFFT_SUCCESS != err)
-                cv::gpu::cufftError(err, file, line, func);
-        }
+static inline void ___cufftSafeCall(cufftResult_t err, const char *file, const int line, const char *func = "")
+{
+    if (CUFFT_SUCCESS != err)
+        cv::gpu::cufftError(err, file, line, func);
+}
 
-        static inline void ___cublasSafeCall(cublasStatus_t err, const char *file, const int line, const char *func = "")
-        {
-            if (CUBLAS_STATUS_SUCCESS != err)
-                cv::gpu::cublasError(err, file, line, func);
-        }
-    }
+static inline void ___cublasSafeCall(cublasStatus_t err, const char *file, const int line, const char *func = "")
+{
+    if (CUBLAS_STATUS_SUCCESS != err)
+        cv::gpu::cublasError(err, file, line, func);
 }
 
+}}
+
 #endif /* __OPENCV_CUDA_SAFE_CALL_HPP__ */
\ No newline at end of file
diff --git a/modules/gpu/src/cuda/split_merge.cu b/modules/gpu/src/cuda/split_merge.cu
index 25bc29481af61352fc689b125026dbde14e6a3fe..92700edd8a41b8cc08d04c437b97408fdf7094bb 100644
--- a/modules/gpu/src/cuda/split_merge.cu
+++ b/modules/gpu/src/cuda/split_merge.cu
@@ -42,465 +42,467 @@
 
 #include "internal_shared.hpp"
 
-namespace cv { namespace gpu { namespace split_merge {
-
-    template <typename T, size_t elem_size = sizeof(T)>
-    struct TypeTraits 
-    {
-        typedef T type;
-        typedef T type2;
-        typedef T type3;
-        typedef T type4;
-    };
-
-    template <typename T>
-    struct TypeTraits<T, 1>
-    {
-        typedef char type;
-        typedef char2 type2;
-        typedef char3 type3;
-        typedef char4 type4;
-    };
-
-    template <typename T>
-    struct TypeTraits<T, 2>
-    {
-        typedef short type;
-        typedef short2 type2;
-        typedef short3 type3;
-        typedef short4 type4;
-    };
-
-    template <typename T>
-    struct TypeTraits<T, 4> 
-    {
-        typedef int type;
-        typedef int2 type2;
-        typedef int3 type3;
-        typedef int4 type4;
-    };
-
-    template <typename T>
-    struct TypeTraits<T, 8> 
-    {
-        typedef double type;
-        typedef double2 type2;
-        //typedef double3 type3;
-        //typedef double4 type3;
-    };
-
-    typedef void (*MergeFunction)(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream);
-    typedef void (*SplitFunction)(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream);
-
-    //------------------------------------------------------------
-    // Merge    
-
-    template <typename T>
-    __global__ void mergeC2_(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        typedef typename TypeTraits<T>::type2 dst_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const T* src0_y = (const T*)(src0 + y * src0_step);
-        const T* src1_y = (const T*)(src1 + y * src1_step);
-        dst_type* dst_y = (dst_type*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_type dst_elem;
-            dst_elem.x = src0_y[x];
-            dst_elem.y = src1_y[x];
-            dst_y[x] = dst_elem;
-        }
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace split_merge {
+
+template <typename T, size_t elem_size = sizeof(T)>
+struct TypeTraits 
+{
+    typedef T type;
+    typedef T type2;
+    typedef T type3;
+    typedef T type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 1>
+{
+    typedef char type;
+    typedef char2 type2;
+    typedef char3 type3;
+    typedef char4 type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 2>
+{
+    typedef short type;
+    typedef short2 type2;
+    typedef short3 type3;
+    typedef short4 type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 4> 
+{
+    typedef int type;
+    typedef int2 type2;
+    typedef int3 type3;
+    typedef int4 type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 8> 
+{
+    typedef double type;
+    typedef double2 type2;
+    //typedef double3 type3;
+    //typedef double4 type3;
+};
+
+typedef void (*MergeFunction)(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream);
+typedef void (*SplitFunction)(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream);
+
+//------------------------------------------------------------
+// Merge    
+
+template <typename T>
+__global__ void mergeC2_(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    typedef typename TypeTraits<T>::type2 dst_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const T* src0_y = (const T*)(src0 + y * src0_step);
+    const T* src1_y = (const T*)(src1 + y * src1_step);
+    dst_type* dst_y = (dst_type*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_type dst_elem;
+        dst_elem.x = src0_y[x];
+        dst_elem.y = src1_y[x];
+        dst_y[x] = dst_elem;
     }
-
-
-    template <typename T>
-    __global__ void mergeC3_(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        typedef typename TypeTraits<T>::type3 dst_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const T* src0_y = (const T*)(src0 + y * src0_step);
-        const T* src1_y = (const T*)(src1 + y * src1_step);
-        const T* src2_y = (const T*)(src2 + y * src2_step);
-        dst_type* dst_y = (dst_type*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_type dst_elem;
-            dst_elem.x = src0_y[x];
-            dst_elem.y = src1_y[x];
-            dst_elem.z = src2_y[x];
-            dst_y[x] = dst_elem;
-        }
+}
+
+
+template <typename T>
+__global__ void mergeC3_(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    typedef typename TypeTraits<T>::type3 dst_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const T* src0_y = (const T*)(src0 + y * src0_step);
+    const T* src1_y = (const T*)(src1 + y * src1_step);
+    const T* src2_y = (const T*)(src2 + y * src2_step);
+    dst_type* dst_y = (dst_type*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_type dst_elem;
+        dst_elem.x = src0_y[x];
+        dst_elem.y = src1_y[x];
+        dst_elem.z = src2_y[x];
+        dst_y[x] = dst_elem;
     }
-
-
-    template <>
-    __global__ void mergeC3_<double>(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double* src0_y = (const double*)(src0 + y * src0_step);
-        const double* src1_y = (const double*)(src1 + y * src1_step);
-        const double* src2_y = (const double*)(src2 + y * src2_step);
-        double* dst_y = (double*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_y[3 * x] = src0_y[x];
-            dst_y[3 * x + 1] = src1_y[x];
-            dst_y[3 * x + 2] = src2_y[x];
-        }
+}
+
+
+template <>
+__global__ void mergeC3_<double>(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double* src0_y = (const double*)(src0 + y * src0_step);
+    const double* src1_y = (const double*)(src1 + y * src1_step);
+    const double* src2_y = (const double*)(src2 + y * src2_step);
+    double* dst_y = (double*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_y[3 * x] = src0_y[x];
+        dst_y[3 * x + 1] = src1_y[x];
+        dst_y[3 * x + 2] = src2_y[x];
     }
-
-
-    template <typename T>
-    __global__ void mergeC4_(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             const uchar* src3, size_t src3_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        typedef typename TypeTraits<T>::type4 dst_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const T* src0_y = (const T*)(src0 + y * src0_step);
-        const T* src1_y = (const T*)(src1 + y * src1_step);
-        const T* src2_y = (const T*)(src2 + y * src2_step);
-        const T* src3_y = (const T*)(src3 + y * src3_step);
-        dst_type* dst_y = (dst_type*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_type dst_elem;
-            dst_elem.x = src0_y[x];
-            dst_elem.y = src1_y[x];
-            dst_elem.z = src2_y[x];
-            dst_elem.w = src3_y[x];
-            dst_y[x] = dst_elem;
-        }
+}
+
+
+template <typename T>
+__global__ void mergeC4_(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         const uchar* src3, size_t src3_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    typedef typename TypeTraits<T>::type4 dst_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const T* src0_y = (const T*)(src0 + y * src0_step);
+    const T* src1_y = (const T*)(src1 + y * src1_step);
+    const T* src2_y = (const T*)(src2 + y * src2_step);
+    const T* src3_y = (const T*)(src3 + y * src3_step);
+    dst_type* dst_y = (dst_type*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_type dst_elem;
+        dst_elem.x = src0_y[x];
+        dst_elem.y = src1_y[x];
+        dst_elem.z = src2_y[x];
+        dst_elem.w = src3_y[x];
+        dst_y[x] = dst_elem;
     }
-
-
-    template <>
-    __global__ void mergeC4_<double>(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             const uchar* src3, size_t src3_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double* src0_y = (const double*)(src0 + y * src0_step);
-        const double* src1_y = (const double*)(src1 + y * src1_step);
-        const double* src2_y = (const double*)(src2 + y * src2_step);
-        const double* src3_y = (const double*)(src3 + y * src3_step);
-        double2* dst_y = (double2*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_y[2 * x] = make_double2(src0_y[x], src1_y[x]);
-            dst_y[2 * x + 1] = make_double2(src2_y[x], src3_y[x]);
-        }
-    }
-
-
-    template <typename T>
-    static void mergeC2_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
-        mergeC2_<T><<<gridDim, blockDim, 0, stream>>>(
-                src[0].data, src[0].step,
-                src[1].data, src[1].step,
-                dst.rows, dst.cols, dst.data, dst.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <>
+__global__ void mergeC4_<double>(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         const uchar* src3, size_t src3_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double* src0_y = (const double*)(src0 + y * src0_step);
+    const double* src1_y = (const double*)(src1 + y * src1_step);
+    const double* src2_y = (const double*)(src2 + y * src2_step);
+    const double* src3_y = (const double*)(src3 + y * src3_step);
+    double2* dst_y = (double2*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_y[2 * x] = make_double2(src0_y[x], src1_y[x]);
+        dst_y[2 * x + 1] = make_double2(src2_y[x], src3_y[x]);
     }
-
-
-    template <typename T>
-    static void mergeC3_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+}
+
+
+template <typename T>
+static void mergeC2_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
+    mergeC2_<T><<<gridDim, blockDim, 0, stream>>>(
+            src[0].data, src[0].step,
+            src[1].data, src[1].step,
+            dst.rows, dst.cols, dst.data, dst.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void mergeC3_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
+    mergeC3_<T><<<gridDim, blockDim, 0, stream>>>(
+            src[0].data, src[0].step,
+            src[1].data, src[1].step,
+            src[2].data, src[2].step,
+            dst.rows, dst.cols, dst.data, dst.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void mergeC4_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
+    mergeC4_<T><<<gridDim, blockDim, 0, stream>>>(
+            src[0].data, src[0].step,
+            src[1].data, src[1].step,
+            src[2].data, src[2].step,
+            src[3].data, src[3].step,
+            dst.rows, dst.cols, dst.data, dst.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+void merge_caller(const DevMem2Db* src, DevMem2Db& dst,
+                             int total_channels, size_t elem_size,
+                             const cudaStream_t& stream)
+{
+    static MergeFunction merge_func_tbl[] =
     {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
-        mergeC3_<T><<<gridDim, blockDim, 0, stream>>>(
-                src[0].data, src[0].step,
-                src[1].data, src[1].step,
-                src[2].data, src[2].step,
-                dst.rows, dst.cols, dst.data, dst.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+        mergeC2_<char>, mergeC2_<short>, mergeC2_<int>, 0, mergeC2_<double>,
+        mergeC3_<char>, mergeC3_<short>, mergeC3_<int>, 0, mergeC3_<double>,
+        mergeC4_<char>, mergeC4_<short>, mergeC4_<int>, 0, mergeC4_<double>,
+    };
 
+    size_t merge_func_id = (total_channels - 2) * 5 + (elem_size >> 1);
+    MergeFunction merge_func = merge_func_tbl[merge_func_id];
 
-    template <typename T>
-    static void mergeC4_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
-        mergeC4_<T><<<gridDim, blockDim, 0, stream>>>(
-                src[0].data, src[0].step,
-                src[1].data, src[1].step,
-                src[2].data, src[2].step,
-                src[3].data, src[3].step,
-                dst.rows, dst.cols, dst.data, dst.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+    if (merge_func == 0)
+        cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
 
+    merge_func(src, dst, stream);
+}
 
-    extern "C" void merge_caller(const DevMem2Db* src, DevMem2Db& dst,
-                                 int total_channels, size_t elem_size,
-                                 const cudaStream_t& stream)
-    {
-        static MergeFunction merge_func_tbl[] =
-        {
-            mergeC2_<char>, mergeC2_<short>, mergeC2_<int>, 0, mergeC2_<double>,
-            mergeC3_<char>, mergeC3_<short>, mergeC3_<int>, 0, mergeC3_<double>,
-            mergeC4_<char>, mergeC4_<short>, mergeC4_<int>, 0, mergeC4_<double>,
-        };
 
-        size_t merge_func_id = (total_channels - 2) * 5 + (elem_size >> 1);
-        MergeFunction merge_func = merge_func_tbl[merge_func_id];
 
-        if (merge_func == 0)
-            cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
-
-        merge_func(src, dst, stream);
-    }
+//------------------------------------------------------------
+// Split
 
 
+template <typename T>
+__global__ void splitC2_(const uchar* src, size_t src_step, 
+                        int rows, int cols,
+                        uchar* dst0, size_t dst0_step,
+                        uchar* dst1, size_t dst1_step)
+{
+    typedef typename TypeTraits<T>::type2 src_type;
 
-    //------------------------------------------------------------
-    // Split
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
+    const src_type* src_y = (const src_type*)(src + y * src_step);
+    T* dst0_y = (T*)(dst0 + y * dst0_step);
+    T* dst1_y = (T*)(dst1 + y * dst1_step);
 
-    template <typename T>
-    __global__ void splitC2_(const uchar* src, size_t src_step, 
-                            int rows, int cols,
-                            uchar* dst0, size_t dst0_step,
-                            uchar* dst1, size_t dst1_step)
+    if (x < cols && y < rows) 
     {
-        typedef typename TypeTraits<T>::type2 src_type;
+        src_type src_elem = src_y[x];
+        dst0_y[x] = src_elem.x;
+        dst1_y[x] = src_elem.y;
+    }
+}
 
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        const src_type* src_y = (const src_type*)(src + y * src_step);
-        T* dst0_y = (T*)(dst0 + y * dst0_step);
-        T* dst1_y = (T*)(dst1 + y * dst1_step);
+template <typename T>
+__global__ void splitC3_(const uchar* src, size_t src_step, 
+                        int rows, int cols,
+                        uchar* dst0, size_t dst0_step,
+                        uchar* dst1, size_t dst1_step,
+                        uchar* dst2, size_t dst2_step)
+{
+    typedef typename TypeTraits<T>::type3 src_type;
 
-        if (x < cols && y < rows) 
-        {
-            src_type src_elem = src_y[x];
-            dst0_y[x] = src_elem.x;
-            dst1_y[x] = src_elem.y;
-        }
-    }
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
+    const src_type* src_y = (const src_type*)(src + y * src_step);
+    T* dst0_y = (T*)(dst0 + y * dst0_step);
+    T* dst1_y = (T*)(dst1 + y * dst1_step);
+    T* dst2_y = (T*)(dst2 + y * dst2_step);
 
-    template <typename T>
-    __global__ void splitC3_(const uchar* src, size_t src_step, 
-                            int rows, int cols,
-                            uchar* dst0, size_t dst0_step,
-                            uchar* dst1, size_t dst1_step,
-                            uchar* dst2, size_t dst2_step)
+    if (x < cols && y < rows) 
     {
-        typedef typename TypeTraits<T>::type3 src_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const src_type* src_y = (const src_type*)(src + y * src_step);
-        T* dst0_y = (T*)(dst0 + y * dst0_step);
-        T* dst1_y = (T*)(dst1 + y * dst1_step);
-        T* dst2_y = (T*)(dst2 + y * dst2_step);
-
-        if (x < cols && y < rows) 
-        {
-            src_type src_elem = src_y[x];
-            dst0_y[x] = src_elem.x;
-            dst1_y[x] = src_elem.y;
-            dst2_y[x] = src_elem.z;
-        }
+        src_type src_elem = src_y[x];
+        dst0_y[x] = src_elem.x;
+        dst1_y[x] = src_elem.y;
+        dst2_y[x] = src_elem.z;
     }
+}
 
 
-    template <>
-    __global__ void splitC3_<double>(
-            const uchar* src, size_t src_step, int rows, int cols,
-            uchar* dst0, size_t dst0_step,
-            uchar* dst1, size_t dst1_step,
-            uchar* dst2, size_t dst2_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double* src_y = (const double*)(src + y * src_step);
-        double* dst0_y = (double*)(dst0 + y * dst0_step);
-        double* dst1_y = (double*)(dst1 + y * dst1_step);
-        double* dst2_y = (double*)(dst2 + y * dst2_step);
-
-        if (x < cols && y < rows) 
-        {
-            dst0_y[x] = src_y[3 * x];
-            dst1_y[x] = src_y[3 * x + 1];
-            dst2_y[x] = src_y[3 * x + 2];
-        }
-    }
+template <>
+__global__ void splitC3_<double>(
+        const uchar* src, size_t src_step, int rows, int cols,
+        uchar* dst0, size_t dst0_step,
+        uchar* dst1, size_t dst1_step,
+        uchar* dst2, size_t dst2_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
+    const double* src_y = (const double*)(src + y * src_step);
+    double* dst0_y = (double*)(dst0 + y * dst0_step);
+    double* dst1_y = (double*)(dst1 + y * dst1_step);
+    double* dst2_y = (double*)(dst2 + y * dst2_step);
 
-    template <typename T>
-    __global__ void splitC4_(const uchar* src, size_t src_step, int rows, int cols,
-                            uchar* dst0, size_t dst0_step,
-                            uchar* dst1, size_t dst1_step,
-                            uchar* dst2, size_t dst2_step,
-                            uchar* dst3, size_t dst3_step)
+    if (x < cols && y < rows) 
     {
-        typedef typename TypeTraits<T>::type4 src_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const src_type* src_y = (const src_type*)(src + y * src_step);
-        T* dst0_y = (T*)(dst0 + y * dst0_step);
-        T* dst1_y = (T*)(dst1 + y * dst1_step);
-        T* dst2_y = (T*)(dst2 + y * dst2_step);
-        T* dst3_y = (T*)(dst3 + y * dst3_step);
-
-        if (x < cols && y < rows) 
-        {
-            src_type src_elem = src_y[x];
-            dst0_y[x] = src_elem.x;
-            dst1_y[x] = src_elem.y;
-            dst2_y[x] = src_elem.z;
-            dst3_y[x] = src_elem.w;
-        }
+        dst0_y[x] = src_y[3 * x];
+        dst1_y[x] = src_y[3 * x + 1];
+        dst2_y[x] = src_y[3 * x + 2];
     }
+}
 
 
-    template <>
-    __global__ void splitC4_<double>(
-            const uchar* src, size_t src_step, int rows, int cols,
-            uchar* dst0, size_t dst0_step,
-            uchar* dst1, size_t dst1_step,
-            uchar* dst2, size_t dst2_step,
-            uchar* dst3, size_t dst3_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double2* src_y = (const double2*)(src + y * src_step);
-        double* dst0_y = (double*)(dst0 + y * dst0_step);
-        double* dst1_y = (double*)(dst1 + y * dst1_step);
-        double* dst2_y = (double*)(dst2 + y * dst2_step);
-        double* dst3_y = (double*)(dst3 + y * dst3_step);
-
-        if (x < cols && y < rows) 
-        {
-            double2 src_elem1 = src_y[2 * x];
-            double2 src_elem2 = src_y[2 * x + 1];
-            dst0_y[x] = src_elem1.x;
-            dst1_y[x] = src_elem1.y;
-            dst2_y[x] = src_elem2.x;
-            dst3_y[x] = src_elem2.y;
-        }
-    }
+template <typename T>
+__global__ void splitC4_(const uchar* src, size_t src_step, int rows, int cols,
+                        uchar* dst0, size_t dst0_step,
+                        uchar* dst1, size_t dst1_step,
+                        uchar* dst2, size_t dst2_step,
+                        uchar* dst3, size_t dst3_step)
+{
+    typedef typename TypeTraits<T>::type4 src_type;
 
-    template <typename T>
-    static void splitC2_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
-        splitC2_<T><<<gridDim, blockDim, 0, stream>>>(
-                src.data, src.step, src.rows, src.cols,
-                dst[0].data, dst[0].step,
-                dst[1].data, dst[1].step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
+    const src_type* src_y = (const src_type*)(src + y * src_step);
+    T* dst0_y = (T*)(dst0 + y * dst0_step);
+    T* dst1_y = (T*)(dst1 + y * dst1_step);
+    T* dst2_y = (T*)(dst2 + y * dst2_step);
+    T* dst3_y = (T*)(dst3 + y * dst3_step);
 
-    template <typename T>
-    static void splitC3_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+    if (x < cols && y < rows) 
     {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
-        splitC3_<T><<<gridDim, blockDim, 0, stream>>>(
-                src.data, src.step, src.rows, src.cols,
-                dst[0].data, dst[0].step,
-                dst[1].data, dst[1].step,
-                dst[2].data, dst[2].step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
+        src_type src_elem = src_y[x];
+        dst0_y[x] = src_elem.x;
+        dst1_y[x] = src_elem.y;
+        dst2_y[x] = src_elem.z;
+        dst3_y[x] = src_elem.w;
     }
-
-
-    template <typename T>
-    static void splitC4_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+}
+
+
+template <>
+__global__ void splitC4_<double>(
+        const uchar* src, size_t src_step, int rows, int cols,
+        uchar* dst0, size_t dst0_step,
+        uchar* dst1, size_t dst1_step,
+        uchar* dst2, size_t dst2_step,
+        uchar* dst3, size_t dst3_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double2* src_y = (const double2*)(src + y * src_step);
+    double* dst0_y = (double*)(dst0 + y * dst0_step);
+    double* dst1_y = (double*)(dst1 + y * dst1_step);
+    double* dst2_y = (double*)(dst2 + y * dst2_step);
+    double* dst3_y = (double*)(dst3 + y * dst3_step);
+
+    if (x < cols && y < rows) 
     {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
-        splitC4_<T><<<gridDim, blockDim, 0, stream>>>(
-                 src.data, src.step, src.rows, src.cols,
-                 dst[0].data, dst[0].step,
-                 dst[1].data, dst[1].step,
-                 dst[2].data, dst[2].step,
-                 dst[3].data, dst[3].step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
+        double2 src_elem1 = src_y[2 * x];
+        double2 src_elem2 = src_y[2 * x + 1];
+        dst0_y[x] = src_elem1.x;
+        dst1_y[x] = src_elem1.y;
+        dst2_y[x] = src_elem2.x;
+        dst3_y[x] = src_elem2.y;
     }
-
-
-    extern "C" void split_caller(const DevMem2Db& src, DevMem2Db* dst,
-                                 int num_channels, size_t elem_size1,
-                                 const cudaStream_t& stream)
+}
+
+template <typename T>
+static void splitC2_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
+    splitC2_<T><<<gridDim, blockDim, 0, stream>>>(
+            src.data, src.step, src.rows, src.cols,
+            dst[0].data, dst[0].step,
+            dst[1].data, dst[1].step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void splitC3_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
+    splitC3_<T><<<gridDim, blockDim, 0, stream>>>(
+            src.data, src.step, src.rows, src.cols,
+            dst[0].data, dst[0].step,
+            dst[1].data, dst[1].step,
+            dst[2].data, dst[2].step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void splitC4_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
+    splitC4_<T><<<gridDim, blockDim, 0, stream>>>(
+             src.data, src.step, src.rows, src.cols,
+             dst[0].data, dst[0].step,
+             dst[1].data, dst[1].step,
+             dst[2].data, dst[2].step,
+             dst[3].data, dst[3].step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+void split_caller(const DevMem2Db& src, DevMem2Db* dst, int num_channels, size_t elem_size1, const cudaStream_t& stream)
+{
+    static SplitFunction split_func_tbl[] =
     {
-        static SplitFunction split_func_tbl[] =
-        {
-            splitC2_<char>, splitC2_<short>, splitC2_<int>, 0, splitC2_<double>,
-            splitC3_<char>, splitC3_<short>, splitC3_<int>, 0, splitC3_<double>,
-            splitC4_<char>, splitC4_<short>, splitC4_<int>, 0, splitC4_<double>,
-        };
+        splitC2_<char>, splitC2_<short>, splitC2_<int>, 0, splitC2_<double>,
+        splitC3_<char>, splitC3_<short>, splitC3_<int>, 0, splitC3_<double>,
+        splitC4_<char>, splitC4_<short>, splitC4_<int>, 0, splitC4_<double>,
+    };
 
-        size_t split_func_id = (num_channels - 2) * 5 + (elem_size1 >> 1);
-        SplitFunction split_func = split_func_tbl[split_func_id];
+    size_t split_func_id = (num_channels - 2) * 5 + (elem_size1 >> 1);
+    SplitFunction split_func = split_func_tbl[split_func_id];
 
-        if (split_func == 0)
-            cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
+    if (split_func == 0)
+        cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
 
-        split_func(src, dst, stream);
-    }
+    split_func(src, dst, stream);
+}
+
+} // namespace split_merge
 
-}}} // namespace cv::gpu::split_merge
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/stereobm.cu b/modules/gpu/src/cuda/stereobm.cu
index 3e99ce4d441b0d62f7d5d9e21319501fe5ce8539..605ee0b064b545cf8cde373466e5fddb115c19db 100644
--- a/modules/gpu/src/cuda/stereobm.cu
+++ b/modules/gpu/src/cuda/stereobm.cu
@@ -40,23 +40,18 @@
 //
 //M*/
 
-//#include "internal_shared.hpp"
-#include "opencv2/gpu/devmem2d.hpp"
-#include "safe_call.hpp"
-static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
+#include "internal_shared.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-using namespace cv::gpu;
+namespace stereobm {
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////// Streeo BM ////////////////////////////////////////////////
+/////////////////////////////////////// Stereo BM ////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define ROWSperTHREAD 21     // the number of rows a thread will process
 
-namespace cv { namespace gpu  { namespace bm
-{
-
 #define BLOCK_W 128          // the thread block width (464)
 #define N_DISPARITIES 8
 
@@ -117,7 +112,7 @@ __device__ uint2 MinSSD(volatile unsigned int *col_ssd_cache, volatile unsigned
     __syncthreads();
     ssd[7] = CalcSSD<RADIUS>(col_ssd_cache, col_ssd + 7 * (BLOCK_W + 2 * RADIUS));
 
-    int mssd = min(min(min(ssd[0], ssd[1]), min(ssd[4], ssd[5])), min(min(ssd[2], ssd[3]), min(ssd[6], ssd[7])));
+    int mssd = ::min(::min(::min(ssd[0], ssd[1]), ::min(ssd[4], ssd[5])), ::min(::min(ssd[2], ssd[3]), ::min(ssd[6], ssd[7])));
 
     int bestIdx = 0;
     for (int i = 0; i < N_DISPARITIES; i++)
@@ -252,7 +247,7 @@ __global__ void stereoKernel(unsigned char *left, unsigned char *right, size_t i
         for(uint *ptr = minSSDImage; ptr != minSSDImage_end; ptr += minssd_step )
             *ptr = 0xFFFFFFFF;
     }*/
-    int end_row = min(ROWSperTHREAD, cheight - Y - RADIUS);
+    int end_row = ::min(ROWSperTHREAD, cheight - Y - RADIUS);
     int y_tex;
     int x_tex = X - RADIUS;
 
@@ -346,7 +341,7 @@ const static kernel_caller_t callers[] =
 };
 const int calles_num = sizeof(callers)/sizeof(callers[0]);
 
-extern "C" void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int maxdisp, int winsz, const DevMem2D_<unsigned int>& minSSD_buf, cudaStream_t& stream)
+void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int maxdisp, int winsz, const DevMem2D_<unsigned int>& minSSD_buf, cudaStream_t& stream)
 {
     int winsz2 = winsz >> 1;
 
@@ -375,7 +370,7 @@ extern "C" void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, cons
 
 texture<unsigned char, 2, cudaReadModeElementType> texForSobel;
 
-extern "C" __global__ void prefilter_kernel(DevMem2Db output, int prefilterCap)
+__global__ void prefilter_kernel(DevMem2Db output, int prefilterCap)
 {
     int x = blockDim.x * blockIdx.x + threadIdx.x;
     int y = blockDim.y * blockIdx.y + threadIdx.y;
@@ -387,12 +382,12 @@ extern "C" __global__ void prefilter_kernel(DevMem2Db output, int prefilterCap)
                    (int)tex2D(texForSobel, x - 1, y + 1) * (-1) + (int)tex2D(texForSobel, x + 1, y + 1) * (1);
 
 
-        conv = min(min(max(-prefilterCap, conv), prefilterCap) + prefilterCap, 255);
+        conv = ::min(::min(::max(-prefilterCap, conv), prefilterCap) + prefilterCap, 255);
         output.ptr(y)[x] = conv & 0xFF;
     }
 }
 
-extern "C" void prefilter_xsobel(const DevMem2Db& input, const DevMem2Db& output, int prefilterCap, cudaStream_t & stream)
+void prefilter_xsobel(const DevMem2Db& input, const DevMem2Db& output, int prefilterCap, cudaStream_t & stream)
 {
     cudaChannelFormatDesc desc = cudaCreateChannelDesc<unsigned char>();
     cudaSafeCall( cudaBindTexture2D( 0, texForSobel, input.data, desc, input.cols, input.rows, input.step ) );
@@ -451,7 +446,7 @@ __device__ float CalcSums(float *cols, float *cols_cache, int winsz)
 
 #define RpT (2 * ROWSperTHREAD)  // got experimentally
 
-extern "C" __global__ void textureness_kernel(DevMem2Db disp, int winsz, float threshold)
+__global__ void textureness_kernel(DevMem2Db disp, int winsz, float threshold)
 {
     int winsz2 = winsz/2;
     int n_dirty_pixels = (winsz2) * 2;
@@ -462,7 +457,7 @@ extern "C" __global__ void textureness_kernel(DevMem2Db disp, int winsz, float t
 
     int x = blockIdx.x * blockDim.x + threadIdx.x;
     int beg_row = blockIdx.y * RpT;
-    int end_row = min(beg_row + RpT, disp.rows);
+    int end_row = ::min(beg_row + RpT, disp.rows);
 
     if (x < disp.cols)
     {
@@ -510,7 +505,7 @@ extern "C" __global__ void textureness_kernel(DevMem2Db disp, int winsz, float t
     }
 }
 
-extern "C" void postfilter_textureness(const DevMem2Db& input, int winsz, float avgTexturenessThreshold, const DevMem2Db& disp, cudaStream_t & stream)
+void postfilter_textureness(const DevMem2Db& input, int winsz, float avgTexturenessThreshold, const DevMem2Db& disp, cudaStream_t & stream)
 {
     avgTexturenessThreshold *= winsz * winsz;
 
@@ -537,4 +532,6 @@ extern "C" void postfilter_textureness(const DevMem2Db& input, int winsz, float
     cudaSafeCall( cudaUnbindTexture (texForTF) );
 }
 
-}}}
+} // namespace stereobm
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/stereobp.cu b/modules/gpu/src/cuda/stereobp.cu
index 9a980cfe5cc2881bd773c88f722798c45f4f4c0c..ab626ffaf1b09b31b5ef87dd84439aa28f2f7e1d 100644
--- a/modules/gpu/src/cuda/stereobp.cu
+++ b/modules/gpu/src/cuda/stereobp.cu
@@ -44,484 +44,489 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace stereobp {
 
-namespace cv { namespace gpu { namespace bp
-{
 ///////////////////////////////////////////////////////////////
 /////////////////////// load constants ////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    __constant__ int   cndisp;
-    __constant__ float cmax_data_term;
-    __constant__ float cdata_weight;
-    __constant__ float cmax_disc_term;
-    __constant__ float cdisc_single_jump;
+__constant__ int   cndisp;
+__constant__ float cmax_data_term;
+__constant__ float cdata_weight;
+__constant__ float cmax_disc_term;
+__constant__ float cdisc_single_jump;
 
-    void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(cndisp,            &ndisp,            sizeof(int  )) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmax_data_term,    &max_data_term,    sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdata_weight,      &data_weight,      sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmax_disc_term,    &max_disc_term,    sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdisc_single_jump, &disc_single_jump, sizeof(float)) );
-    }
+void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(cndisp,            &ndisp,            sizeof(int  )) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_data_term,    &max_data_term,    sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdata_weight,      &data_weight,      sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_disc_term,    &max_disc_term,    sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdisc_single_jump, &disc_single_jump, sizeof(float)) );
+}
 
 ///////////////////////////////////////////////////////////////
 ////////////////////////// comp data //////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <int cn> struct PixDiff;
-    template <> struct PixDiff<1>
+template <int cn> struct PixDiff;
+template <> struct PixDiff<1>
+{
+    __device__ __forceinline__ PixDiff(const uchar* ls)
     {
-        __device__ __forceinline__ PixDiff(const uchar* ls)
-        {
-            l = *ls;
-        }
-        __device__ __forceinline__ float operator()(const uchar* rs) const
-        {
-            return abs((int)l - *rs);
-        }
-        uchar l;
-    };
-    template <> struct PixDiff<3>
+        l = *ls;
+    }
+    __device__ __forceinline__ float operator()(const uchar* rs) const
     {
-        __device__ __forceinline__ PixDiff(const uchar* ls)
-        {
-            l = *((uchar3*)ls);
-        }
-        __device__ __forceinline__ float operator()(const uchar* rs) const
-        {
-            const float tr = 0.299f;
-            const float tg = 0.587f;
-            const float tb = 0.114f;
+        return ::abs((int)l - *rs);
+    }
+    uchar l;
+};
+template <> struct PixDiff<3>
+{
+    __device__ __forceinline__ PixDiff(const uchar* ls)
+    {
+        l = *((uchar3*)ls);
+    }
+    __device__ __forceinline__ float operator()(const uchar* rs) const
+    {
+        const float tr = 0.299f;
+        const float tg = 0.587f;
+        const float tb = 0.114f;
 
-            float val  = tb * abs((int)l.x - rs[0]);
-                  val += tg * abs((int)l.y - rs[1]);
-                  val += tr * abs((int)l.z - rs[2]);
+        float val  = tb * ::abs((int)l.x - rs[0]);
+              val += tg * ::abs((int)l.y - rs[1]);
+              val += tr * ::abs((int)l.z - rs[2]);
 
-            return val;
-        }
-        uchar3 l;
-    };
-    template <> struct PixDiff<4>
+        return val;
+    }
+    uchar3 l;
+};
+template <> struct PixDiff<4>
+{
+    __device__ __forceinline__ PixDiff(const uchar* ls)
     {
-        __device__ __forceinline__ PixDiff(const uchar* ls)
-        {
-            l = *((uchar4*)ls);
-        }
-        __device__ __forceinline__ float operator()(const uchar* rs) const
-        {
-            const float tr = 0.299f;
-            const float tg = 0.587f;
-            const float tb = 0.114f;
+        l = *((uchar4*)ls);
+    }
+    __device__ __forceinline__ float operator()(const uchar* rs) const
+    {
+        const float tr = 0.299f;
+        const float tg = 0.587f;
+        const float tb = 0.114f;
 
-            uchar4 r = *((uchar4*)rs);
+        uchar4 r = *((uchar4*)rs);
 
-            float val  = tb * abs((int)l.x - r.x);
-                  val += tg * abs((int)l.y - r.y);
-                  val += tr * abs((int)l.z - r.z);
+        float val  = tb * ::abs((int)l.x - r.x);
+              val += tg * ::abs((int)l.y - r.y);
+              val += tr * ::abs((int)l.z - r.z);
 
-            return val;
-        }
-        uchar4 l;
-    };
+        return val;
+    }
+    uchar4 l;
+};
 
-    template <int cn, typename D>
-    __global__ void comp_data(const DevMem2Db left, const PtrStepb right, PtrElemStep_<D> data)
+template <int cn, typename D>
+__global__ void comp_data(const DevMem2Db left, const PtrStepb right, PtrElemStep_<D> data)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y > 0 && y < left.rows - 1 && x > 0 && x < left.cols - 1)
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const uchar* ls = left.ptr(y) + x * cn;
+        const PixDiff<cn> pixDiff(ls);
+        const uchar* rs = right.ptr(y) + x * cn;
 
-        if (y > 0 && y < left.rows - 1 && x > 0 && x < left.cols - 1)
-        {
-            const uchar* ls = left.ptr(y) + x * cn;
-            const PixDiff<cn> pixDiff(ls);
-            const uchar* rs = right.ptr(y) + x * cn;
+        D* ds = data.ptr(y) + x;
+        const size_t disp_step = data.step * left.rows;
 
-            D* ds = data.ptr(y) + x;
-            const size_t disp_step = data.step * left.rows;
+        for (int disp = 0; disp < cndisp; disp++)
+        {
+            if (x - disp >= 1)
+            {
+                float val = pixDiff(rs - disp * cn);
 
-            for (int disp = 0; disp < cndisp; disp++)
+                ds[disp * disp_step] = saturate_cast<D>(fmin(cdata_weight * val, cdata_weight * cmax_data_term));
+            }
+            else
             {
-                if (x - disp >= 1)
-                {
-                    float val = pixDiff(rs - disp * cn);
-
-                    ds[disp * disp_step] = saturate_cast<D>(fmin(cdata_weight * val, cdata_weight * cmax_data_term));
-                }
-                else
-                {
-                    ds[disp * disp_step] = saturate_cast<D>(cdata_weight * cmax_data_term);
-                }
+                ds[disp * disp_step] = saturate_cast<D>(cdata_weight * cmax_data_term);
             }
         }
     }
+}
 
-    template<typename T, typename D>
-    void comp_data_gpu(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream);
+template<typename T, typename D>
+void comp_data_gpu(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream);
 
-    template <> void comp_data_gpu<uchar, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <> void comp_data_gpu<uchar, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<1, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<1, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-    template <> void comp_data_gpu<uchar, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+template <> void comp_data_gpu<uchar, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<1, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<1, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <> void comp_data_gpu<uchar3, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <> void comp_data_gpu<uchar3, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<3, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<3, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-    template <> void comp_data_gpu<uchar3, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+template <> void comp_data_gpu<uchar3, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<3, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<3, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <> void comp_data_gpu<uchar4, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <> void comp_data_gpu<uchar4, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<4, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<4, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-    template <> void comp_data_gpu<uchar4, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+template <> void comp_data_gpu<uchar4, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<4, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<4, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 ///////////////////////////////////////////////////////////////
 //////////////////////// data step down ///////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __global__ void data_step_down(int dst_cols, int dst_rows, int src_rows, const PtrStep<T> src, PtrStep<T> dst)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename T>
+__global__ void data_step_down(int dst_cols, int dst_rows, int src_rows, const PtrStep<T> src, PtrStep<T> dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < dst_cols && y < dst_rows)
+    if (x < dst_cols && y < dst_rows)
+    {
+        for (int d = 0; d < cndisp; ++d)
         {
-            for (int d = 0; d < cndisp; ++d)
-            {
-                float dst_reg  = src.ptr(d * src_rows + (2*y+0))[(2*x+0)];
-                      dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+0)];
-                      dst_reg += src.ptr(d * src_rows + (2*y+0))[(2*x+1)];
-                      dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+1)];
+            float dst_reg  = src.ptr(d * src_rows + (2*y+0))[(2*x+0)];
+                  dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+0)];
+                  dst_reg += src.ptr(d * src_rows + (2*y+0))[(2*x+1)];
+                  dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+1)];
 
-                dst.ptr(d * dst_rows + y)[x] = saturate_cast<T>(dst_reg);
-            }
+            dst.ptr(d * dst_rows + y)[x] = saturate_cast<T>(dst_reg);
         }
     }
+}
 
-    template<typename T>
-    void data_step_down_gpu(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template<typename T>
+void data_step_down_gpu(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(dst_cols, threads.x);
-        grid.y = divUp(dst_rows, threads.y);
+    grid.x = divUp(dst_cols, threads.x);
+    grid.y = divUp(dst_rows, threads.y);
 
-        data_step_down<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)src, (DevMem2D_<T>)dst);
-        cudaSafeCall( cudaGetLastError() );
+    data_step_down<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)src, (DevMem2D_<T>)dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template void data_step_down_gpu<short>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
-    template void data_step_down_gpu<float>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
+template void data_step_down_gpu<short>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
+template void data_step_down_gpu<float>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////
 /////////////////// level up messages  ////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __global__ void level_up_message(int dst_cols, int dst_rows, int src_rows, const PtrElemStep_<T> src, PtrElemStep_<T> dst)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename T>
+__global__ void level_up_message(int dst_cols, int dst_rows, int src_rows, const PtrElemStep_<T> src, PtrElemStep_<T> dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < dst_cols && y < dst_rows)
-        {
-            const size_t dst_disp_step = dst.step * dst_rows;
-            const size_t src_disp_step = src.step * src_rows;
+    if (x < dst_cols && y < dst_rows)
+    {
+        const size_t dst_disp_step = dst.step * dst_rows;
+        const size_t src_disp_step = src.step * src_rows;
 
-            T*       dstr = dst.ptr(y  ) + x;
-            const T* srcr = src.ptr(y/2) + x/2;
+        T*       dstr = dst.ptr(y  ) + x;
+        const T* srcr = src.ptr(y/2) + x/2;
 
-            for (int d = 0; d < cndisp; ++d)
-                dstr[d * dst_disp_step] = srcr[d * src_disp_step];
-        }
+        for (int d = 0; d < cndisp; ++d)
+            dstr[d * dst_disp_step] = srcr[d * src_disp_step];
     }
+}
 
-    template <typename T>
-    void level_up_messages_gpu(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename T>
+void level_up_messages_gpu(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(dst_cols, threads.x);
-        grid.y = divUp(dst_rows, threads.y);
+    grid.x = divUp(dst_cols, threads.x);
+    grid.y = divUp(dst_rows, threads.y);
 
-        int src_idx = (dst_idx + 1) & 1;
+    int src_idx = (dst_idx + 1) & 1;
 
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mus[src_idx], (DevMem2D_<T>)mus[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mds[src_idx], (DevMem2D_<T>)mds[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mls[src_idx], (DevMem2D_<T>)mls[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mrs[src_idx], (DevMem2D_<T>)mrs[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mus[src_idx], (DevMem2D_<T>)mus[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mds[src_idx], (DevMem2D_<T>)mds[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
+
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mls[src_idx], (DevMem2D_<T>)mls[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
+
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mrs[src_idx], (DevMem2D_<T>)mrs[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template void level_up_messages_gpu<short>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
-    template void level_up_messages_gpu<float>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
+template void level_up_messages_gpu<short>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
+template void level_up_messages_gpu<float>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////
 ////////////////////  calc all iterations /////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __device__ void calc_min_linear_penalty(T* dst, size_t step)
+template <typename T>
+__device__ void calc_min_linear_penalty(T* dst, size_t step)
+{
+    float prev = dst[0];
+    float cur;
+    for (int disp = 1; disp < cndisp; ++disp)
     {
-        float prev = dst[0];
-        float cur;
-        for (int disp = 1; disp < cndisp; ++disp)
+        prev += cdisc_single_jump;
+        cur = dst[step * disp];
+        if (prev < cur)
         {
-            prev += cdisc_single_jump;
-            cur = dst[step * disp];
-            if (prev < cur)
-            {
-                cur = prev;
-                dst[step * disp] = saturate_cast<T>(prev);
-            }
-            prev = cur;
+            cur = prev;
+            dst[step * disp] = saturate_cast<T>(prev);
         }
+        prev = cur;
+    }
 
-        prev = dst[(cndisp - 1) * step];
-        for (int disp = cndisp - 2; disp >= 0; disp--)
+    prev = dst[(cndisp - 1) * step];
+    for (int disp = cndisp - 2; disp >= 0; disp--)
+    {
+        prev += cdisc_single_jump;
+        cur = dst[step * disp];
+        if (prev < cur)
         {
-            prev += cdisc_single_jump;
-            cur = dst[step * disp];
-            if (prev < cur)
-            {
-                cur = prev;
-                dst[step * disp] = saturate_cast<T>(prev);
-            }
-            prev = cur;
+            cur = prev;
+            dst[step * disp] = saturate_cast<T>(prev);
         }
+        prev = cur;
     }
+}
 
-    template <typename T>
-    __device__ void message(const T* msg1, const T* msg2, const T* msg3, const T* data, T* dst, size_t msg_disp_step, size_t data_disp_step)
-    {
-        float minimum = numeric_limits<float>::max();
+template <typename T>
+__device__ void message(const T* msg1, const T* msg2, const T* msg3, const T* data, T* dst, size_t msg_disp_step, size_t data_disp_step)
+{
+    float minimum = device::numeric_limits<float>::max();
 
-        for(int i = 0; i < cndisp; ++i)
-        {
-            float dst_reg  = msg1[msg_disp_step * i];
-                  dst_reg += msg2[msg_disp_step * i];
-                  dst_reg += msg3[msg_disp_step * i];
-                  dst_reg += data[data_disp_step * i];
+    for(int i = 0; i < cndisp; ++i)
+    {
+        float dst_reg  = msg1[msg_disp_step * i];
+              dst_reg += msg2[msg_disp_step * i];
+              dst_reg += msg3[msg_disp_step * i];
+              dst_reg += data[data_disp_step * i];
 
-            if (dst_reg < minimum)
-                minimum = dst_reg;
+        if (dst_reg < minimum)
+            minimum = dst_reg;
 
-            dst[msg_disp_step * i] = saturate_cast<T>(dst_reg);
-        }
+        dst[msg_disp_step * i] = saturate_cast<T>(dst_reg);
+    }
 
-        calc_min_linear_penalty(dst, msg_disp_step);
+    calc_min_linear_penalty(dst, msg_disp_step);
 
-        minimum += cmax_disc_term;
+    minimum += cmax_disc_term;
 
-        float sum = 0;
-        for(int i = 0; i < cndisp; ++i)
+    float sum = 0;
+    for(int i = 0; i < cndisp; ++i)
+    {
+        float dst_reg = dst[msg_disp_step * i];
+        if (dst_reg > minimum)
         {
-            float dst_reg = dst[msg_disp_step * i];
-            if (dst_reg > minimum)
-            {
-                dst_reg = minimum;
-                dst[msg_disp_step * i] = saturate_cast<T>(minimum);
-            }
-            sum += dst_reg;
+            dst_reg = minimum;
+            dst[msg_disp_step * i] = saturate_cast<T>(minimum);
         }
-        sum /= cndisp;
-
-        for(int i = 0; i < cndisp; ++i)
-            dst[msg_disp_step * i] -= sum;
+        sum += dst_reg;
     }
+    sum /= cndisp;
 
-    template <typename T>
-    __global__ void one_iteration(int t, PtrElemStep_<T> u, T* d, T* l, T* r, const PtrElemStep_<T> data, int cols, int rows)
-    {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
+    for(int i = 0; i < cndisp; ++i)
+        dst[msg_disp_step * i] -= sum;
+}
 
-        if ((y > 0) && (y < rows - 1) && (x > 0) && (x < cols - 1))
-        {
-            T* us = u.ptr(y) + x;
-            T* ds = d + y * u.step + x;
-            T* ls = l + y * u.step + x;
-            T* rs = r + y * u.step + x;
-            const T* dt = data.ptr(y) + x;
-
-            size_t msg_disp_step = u.step * rows;
-            size_t data_disp_step = data.step * rows;
-
-            message(us + u.step, ls      + 1, rs - 1, dt, us, msg_disp_step, data_disp_step);
-            message(ds - u.step, ls      + 1, rs - 1, dt, ds, msg_disp_step, data_disp_step);
-            message(us + u.step, ds - u.step, rs - 1, dt, rs, msg_disp_step, data_disp_step);
-            message(us + u.step, ds - u.step, ls + 1, dt, ls, msg_disp_step, data_disp_step);
-        }
-    }
+template <typename T>
+__global__ void one_iteration(int t, PtrElemStep_<T> u, T* d, T* l, T* r, const PtrElemStep_<T> data, int cols, int rows)
+{
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
 
-    template <typename T>
-    void calc_all_iterations_gpu(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d,
-        const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream)
+    if ((y > 0) && (y < rows - 1) && (x > 0) && (x < cols - 1))
     {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+        T* us = u.ptr(y) + x;
+        T* ds = d + y * u.step + x;
+        T* ls = l + y * u.step + x;
+        T* rs = r + y * u.step + x;
+        const T* dt = data.ptr(y) + x;
+
+        size_t msg_disp_step = u.step * rows;
+        size_t data_disp_step = data.step * rows;
+
+        message(us + u.step, ls      + 1, rs - 1, dt, us, msg_disp_step, data_disp_step);
+        message(ds - u.step, ls      + 1, rs - 1, dt, ds, msg_disp_step, data_disp_step);
+        message(us + u.step, ds - u.step, rs - 1, dt, rs, msg_disp_step, data_disp_step);
+        message(us + u.step, ds - u.step, ls + 1, dt, ls, msg_disp_step, data_disp_step);
+    }
+}
 
-        grid.x = divUp(cols, threads.x << 1);
-        grid.y = divUp(rows, threads.y);
+template <typename T>
+void calc_all_iterations_gpu(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d,
+    const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        for(int t = 0; t < iters; ++t)
-        {
-            one_iteration<T><<<grid, threads, 0, stream>>>(t, (DevMem2D_<T>)u, (T*)d.data, (T*)l.data, (T*)r.data, (DevMem2D_<T>)data, cols, rows);
-            cudaSafeCall( cudaGetLastError() );
+    grid.x = divUp(cols, threads.x << 1);
+    grid.y = divUp(rows, threads.y);
 
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
+    for(int t = 0; t < iters; ++t)
+    {
+        one_iteration<T><<<grid, threads, 0, stream>>>(t, (DevMem2D_<T>)u, (T*)d.data, (T*)l.data, (T*)r.data, (DevMem2D_<T>)data, cols, rows);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
     }
+}
 
-    template void calc_all_iterations_gpu<short>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
-    template void calc_all_iterations_gpu<float>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
+template void calc_all_iterations_gpu<short>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
+template void calc_all_iterations_gpu<float>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////
 /////////////////////////// output ////////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __global__ void output(const PtrElemStep_<T> u, const T* d, const T* l, const T* r, const T* data,
-        DevMem2D_<short> disp)
+template <typename T>
+__global__ void output(const PtrElemStep_<T> u, const T* d, const T* l, const T* r, const T* data,
+    DevMem2D_<short> disp)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y > 0 && y < disp.rows - 1 && x > 0 && x < disp.cols - 1)
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const T* us = u.ptr(y + 1) + x;
+        const T* ds = d + (y - 1) * u.step + x;
+        const T* ls = l + y * u.step + (x + 1);
+        const T* rs = r + y * u.step + (x - 1);
+        const T* dt = data + y * u.step + x;
 
-        if (y > 0 && y < disp.rows - 1 && x > 0 && x < disp.cols - 1)
-        {
-            const T* us = u.ptr(y + 1) + x;
-            const T* ds = d + (y - 1) * u.step + x;
-            const T* ls = l + y * u.step + (x + 1);
-            const T* rs = r + y * u.step + (x - 1);
-            const T* dt = data + y * u.step + x;
+        size_t disp_step = disp.rows * u.step;
 
-            size_t disp_step = disp.rows * u.step;
+        int best = 0;
+        float best_val = numeric_limits<float>::max();
+        for (int d = 0; d < cndisp; ++d)
+        {
+            float val  = us[d * disp_step];
+                  val += ds[d * disp_step];
+                  val += ls[d * disp_step];
+                  val += rs[d * disp_step];
+                  val += dt[d * disp_step];
 
-            int best = 0;
-            float best_val = numeric_limits<float>::max();
-            for (int d = 0; d < cndisp; ++d)
+            if (val < best_val)
             {
-                float val  = us[d * disp_step];
-                      val += ds[d * disp_step];
-                      val += ls[d * disp_step];
-                      val += rs[d * disp_step];
-                      val += dt[d * disp_step];
-
-                if (val < best_val)
-                {
-                    best_val = val;
-                    best = d;
-                }
+                best_val = val;
+                best = d;
             }
-
-            disp.ptr(y)[x] = saturate_cast<short>(best);
         }
+
+        disp.ptr(y)[x] = saturate_cast<short>(best);
     }
+}
 
-    template <typename T>
-    void output_gpu(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data,
-        const DevMem2D_<short>& disp, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename T>
+void output_gpu(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data,
+    const DevMem2D_<short>& disp, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(disp.cols, threads.x);
-        grid.y = divUp(disp.rows, threads.y);
+    grid.x = divUp(disp.cols, threads.x);
+    grid.y = divUp(disp.rows, threads.y);
 
-        output<T><<<grid, threads, 0, stream>>>((DevMem2D_<T>)u, (const T*)d.data, (const T*)l.data, (const T*)r.data, (const T*)data.data, disp);
-        cudaSafeCall( cudaGetLastError() );
+    output<T><<<grid, threads, 0, stream>>>((DevMem2D_<T>)u, (const T*)d.data, (const T*)l.data, (const T*)r.data, (const T*)data.data, disp);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template void output_gpu<short>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
+template void output_gpu<float>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
+
+} // namespace stereobp
 
-    template void output_gpu<short>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
-    template void output_gpu<float>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/stereocsbp.cu b/modules/gpu/src/cuda/stereocsbp.cu
index e43800b1576f1f5a68a4b31482a088da4c36b9e5..bb8e71333aca0a5f6e7e039a7427c264167cada5 100644
--- a/modules/gpu/src/cuda/stereocsbp.cu
+++ b/modules/gpu/src/cuda/stereocsbp.cu
@@ -44,555 +44,552 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-
-namespace cv { namespace gpu { namespace csbp
-{  
+namespace stereocsbp {
 
 ///////////////////////////////////////////////////////////////
 /////////////////////// load constants ////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    __constant__ int cndisp;
+__constant__ int cndisp;
 
-    __constant__ float cmax_data_term;
-    __constant__ float cdata_weight;
-    __constant__ float cmax_disc_term;
-    __constant__ float cdisc_single_jump;
+__constant__ float cmax_data_term;
+__constant__ float cdata_weight;
+__constant__ float cmax_disc_term;
+__constant__ float cdisc_single_jump;
 
-    __constant__ int cth;
+__constant__ int cth;
 
-    __constant__ size_t cimg_step;
-    __constant__ size_t cmsg_step1;
-    __constant__ size_t cmsg_step2;
-    __constant__ size_t cdisp_step1;
-    __constant__ size_t cdisp_step2;
+__constant__ size_t cimg_step;
+__constant__ size_t cmsg_step1;
+__constant__ size_t cmsg_step2;
+__constant__ size_t cdisp_step1;
+__constant__ size_t cdisp_step2;
 
-    __constant__ uchar* cleft;
-    __constant__ uchar* cright;
-    __constant__ uchar* ctemp;
+__constant__ uchar* cleft;
+__constant__ uchar* cright;
+__constant__ uchar* ctemp;
 
 
-    void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th,
-                        const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& temp)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(cndisp, &ndisp, sizeof(int)) );
+void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th,
+                    const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& temp)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(cndisp, &ndisp, sizeof(int)) );
 
-        cudaSafeCall( cudaMemcpyToSymbol(cmax_data_term,    &max_data_term,    sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdata_weight,      &data_weight,      sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmax_disc_term,    &max_disc_term,    sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdisc_single_jump, &disc_single_jump, sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_data_term,    &max_data_term,    sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdata_weight,      &data_weight,      sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_disc_term,    &max_disc_term,    sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdisc_single_jump, &disc_single_jump, sizeof(float)) );
 
-        cudaSafeCall( cudaMemcpyToSymbol(cth, &min_disp_th, sizeof(int)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cth, &min_disp_th, sizeof(int)) );
 
-        cudaSafeCall( cudaMemcpyToSymbol(cimg_step, &left.step, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cimg_step, &left.step, sizeof(size_t)) );
 
-        cudaSafeCall( cudaMemcpyToSymbol(cleft,  &left.data,  sizeof(left.data)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cright, &right.data, sizeof(right.data)) );
-        cudaSafeCall( cudaMemcpyToSymbol(ctemp, &temp.data, sizeof(temp.data)) );
-    }
+    cudaSafeCall( cudaMemcpyToSymbol(cleft,  &left.data,  sizeof(left.data)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cright, &right.data, sizeof(right.data)) );
+    cudaSafeCall( cudaMemcpyToSymbol(ctemp, &temp.data, sizeof(temp.data)) );
+}
 
 ///////////////////////////////////////////////////////////////
 /////////////////////// init data cost ////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <int channels> struct DataCostPerPixel;
-    template <> struct DataCostPerPixel<1>
+template <int channels> struct DataCostPerPixel;
+template <> struct DataCostPerPixel<1>
+{
+    static __device__ __forceinline__ float compute(const uchar* left, const uchar* right)
     {
-        static __device__ __forceinline__ float compute(const uchar* left, const uchar* right)
-        {
-            return fmin(cdata_weight * abs((int)*left - *right), cdata_weight * cmax_data_term);
-        }
-    };
-    template <> struct DataCostPerPixel<3>
+        return fmin(cdata_weight * ::abs((int)*left - *right), cdata_weight * cmax_data_term);
+    }
+};
+template <> struct DataCostPerPixel<3>
+{
+    static __device__ __forceinline__ float compute(const uchar* left, const uchar* right)
     {
-        static __device__ __forceinline__ float compute(const uchar* left, const uchar* right)
-        {
-            float tb = 0.114f * abs((int)left[0] - right[0]);
-            float tg = 0.587f * abs((int)left[1] - right[1]);
-            float tr = 0.299f * abs((int)left[2] - right[2]);
+        float tb = 0.114f * ::abs((int)left[0] - right[0]);
+        float tg = 0.587f * ::abs((int)left[1] - right[1]);
+        float tr = 0.299f * ::abs((int)left[2] - right[2]);
 
-            return fmin(cdata_weight * (tr + tg + tb), cdata_weight * cmax_data_term);
-        }
-    };
-    template <> struct DataCostPerPixel<4>
+        return fmin(cdata_weight * (tr + tg + tb), cdata_weight * cmax_data_term);
+    }
+};
+template <> struct DataCostPerPixel<4>
+{
+    static __device__ __forceinline__ float compute(const uchar* left, const uchar* right)
     {
-        static __device__ __forceinline__ float compute(const uchar* left, const uchar* right)
-        {
-            uchar4 l = *((const uchar4*)left);
-            uchar4 r = *((const uchar4*)right);
+        uchar4 l = *((const uchar4*)left);
+        uchar4 r = *((const uchar4*)right);
 
-            float tb = 0.114f * abs((int)l.x - r.x);
-            float tg = 0.587f * abs((int)l.y - r.y);
-            float tr = 0.299f * abs((int)l.z - r.z);
+        float tb = 0.114f * ::abs((int)l.x - r.x);
+        float tg = 0.587f * ::abs((int)l.y - r.y);
+        float tr = 0.299f * ::abs((int)l.z - r.z);
 
-            return fmin(cdata_weight * (tr + tg + tb), cdata_weight * cmax_data_term);
-        }
-    };
+        return fmin(cdata_weight * (tr + tg + tb), cdata_weight * cmax_data_term);
+    }
+};
 
-    template <typename T>
-    __global__ void get_first_k_initial_global(T* data_cost_selected_, T *selected_disp_pyr, int h, int w, int nr_plane)
+template <typename T>
+__global__ void get_first_k_initial_global(T* data_cost_selected_, T *selected_disp_pyr, int h, int w, int nr_plane)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y < h && x < w)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
+        T* selected_disparity = selected_disp_pyr + y * cmsg_step1 + x;
+        T* data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x;
+        T* data_cost = (T*)ctemp + y * cmsg_step1 + x;
 
-        if (y < h && x < w)
+        for(int i = 0; i < nr_plane; i++)
         {
-            T* selected_disparity = selected_disp_pyr + y * cmsg_step1 + x;
-            T* data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x;
-            T* data_cost = (T*)ctemp + y * cmsg_step1 + x;
-
-            for(int i = 0; i < nr_plane; i++)
+            T minimum = device::numeric_limits<T>::max();
+            int id = 0;
+            for(int d = 0; d < cndisp; d++)
             {
-                T minimum = numeric_limits<T>::max();
-                int id = 0;
-                for(int d = 0; d < cndisp; d++)
+                T cur = data_cost[d * cdisp_step1];
+                if(cur < minimum)
                 {
-                    T cur = data_cost[d * cdisp_step1];
-                    if(cur < minimum)
-                    {
-                        minimum = cur;
-                        id = d;
-                    }
+                    minimum = cur;
+                    id = d;
                 }
-
-                data_cost_selected[i  * cdisp_step1] = minimum;
-                selected_disparity[i  * cdisp_step1] = id;
-                data_cost         [id * cdisp_step1] = numeric_limits<T>::max();
             }
+
+            data_cost_selected[i  * cdisp_step1] = minimum;
+            selected_disparity[i  * cdisp_step1] = id;
+            data_cost         [id * cdisp_step1] = numeric_limits<T>::max();
         }
     }
+}
 
 
-    template <typename T>
-    __global__ void get_first_k_initial_local(T* data_cost_selected_, T* selected_disp_pyr, int h, int w, int nr_plane)
-    {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename T>
+__global__ void get_first_k_initial_local(T* data_cost_selected_, T* selected_disp_pyr, int h, int w, int nr_plane)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (y < h && x < w)
-        {
-            T* selected_disparity = selected_disp_pyr + y * cmsg_step1 + x;
-            T* data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x;
-            T* data_cost = (T*)ctemp + y * cmsg_step1 + x;
+    if (y < h && x < w)
+    {
+        T* selected_disparity = selected_disp_pyr + y * cmsg_step1 + x;
+        T* data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x;
+        T* data_cost = (T*)ctemp + y * cmsg_step1 + x;
 
-            int nr_local_minimum = 0;
+        int nr_local_minimum = 0;
 
-            T prev = data_cost[0 * cdisp_step1];
-            T cur  = data_cost[1 * cdisp_step1];
-            T next = data_cost[2 * cdisp_step1];
+        T prev = data_cost[0 * cdisp_step1];
+        T cur  = data_cost[1 * cdisp_step1];
+        T next = data_cost[2 * cdisp_step1];
 
-            for (int d = 1; d < cndisp - 1 && nr_local_minimum < nr_plane; d++)
+        for (int d = 1; d < cndisp - 1 && nr_local_minimum < nr_plane; d++)
+        {
+            if (cur < prev && cur < next)
             {
-                if (cur < prev && cur < next)
-                {
-                    data_cost_selected[nr_local_minimum * cdisp_step1] = cur;
-                    selected_disparity[nr_local_minimum * cdisp_step1] = d;
+                data_cost_selected[nr_local_minimum * cdisp_step1] = cur;
+                selected_disparity[nr_local_minimum * cdisp_step1] = d;
 
-                    data_cost[d * cdisp_step1] = numeric_limits<T>::max();
+                data_cost[d * cdisp_step1] = numeric_limits<T>::max();
 
-                    nr_local_minimum++;
-                }
-                prev = cur;
-                cur = next;
-                next = data_cost[(d + 1) * cdisp_step1];
+                nr_local_minimum++;
             }
+            prev = cur;
+            cur = next;
+            next = data_cost[(d + 1) * cdisp_step1];
+        }
 
-            for (int i = nr_local_minimum; i < nr_plane; i++)
-            {
-                T minimum = numeric_limits<T>::max();
-                int id = 0;
+        for (int i = nr_local_minimum; i < nr_plane; i++)
+        {
+            T minimum = numeric_limits<T>::max();
+            int id = 0;
 
-                for (int d = 0; d < cndisp; d++)
+            for (int d = 0; d < cndisp; d++)
+            {
+                cur = data_cost[d * cdisp_step1];
+                if (cur < minimum)
                 {
-                    cur = data_cost[d * cdisp_step1];
-                    if (cur < minimum)
-                    {
-                        minimum = cur;
-                        id = d;
-                    }
+                    minimum = cur;
+                    id = d;
                 }
-                data_cost_selected[i * cdisp_step1] = minimum;
-                selected_disparity[i * cdisp_step1] = id;
-
-                data_cost[id * cdisp_step1] = numeric_limits<T>::max();
             }
+            data_cost_selected[i * cdisp_step1] = minimum;
+            selected_disparity[i * cdisp_step1] = id;
+
+            data_cost[id * cdisp_step1] = numeric_limits<T>::max();
         }
     }
+}
 
-    template <typename T, int channels>
-    __global__ void init_data_cost(int h, int w, int level)
-    {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename T, int channels>
+__global__ void init_data_cost(int h, int w, int level)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (y < h && x < w)
-        {
-            int y0 = y << level;
-            int yt = (y + 1) << level;
+    if (y < h && x < w)
+    {
+        int y0 = y << level;
+        int yt = (y + 1) << level;
 
-            int x0 = x << level;
-            int xt = (x + 1) << level;
+        int x0 = x << level;
+        int xt = (x + 1) << level;
 
-            T* data_cost = (T*)ctemp + y * cmsg_step1 + x;
+        T* data_cost = (T*)ctemp + y * cmsg_step1 + x;
 
-            for(int d = 0; d < cndisp; ++d)
+        for(int d = 0; d < cndisp; ++d)
+        {
+            float val = 0.0f;
+            for(int yi = y0; yi < yt; yi++)
             {
-                float val = 0.0f;
-                for(int yi = y0; yi < yt; yi++)
+                for(int xi = x0; xi < xt; xi++)
                 {
-                    for(int xi = x0; xi < xt; xi++)
+                    int xr = xi - d;
+                    if(d < cth || xr < 0)
+                        val += cdata_weight * cmax_data_term;
+                    else
                     {
-                        int xr = xi - d;
-                        if(d < cth || xr < 0)
-                            val += cdata_weight * cmax_data_term;
-                        else
-                        {
-                            const uchar* lle = cleft + yi * cimg_step + xi * channels;
-                            const uchar* lri = cright + yi * cimg_step + xr * channels;
-
-                            val += DataCostPerPixel<channels>::compute(lle, lri);
-                        }
+                        const uchar* lle = cleft + yi * cimg_step + xi * channels;
+                        const uchar* lri = cright + yi * cimg_step + xr * channels;
+
+                        val += DataCostPerPixel<channels>::compute(lle, lri);
                     }
                 }
-                data_cost[cdisp_step1 * d] = saturate_cast<T>(val);
             }
+            data_cost[cdisp_step1 * d] = saturate_cast<T>(val);
         }
     }
+}
 
-    template <typename T, int winsz, int channels>
-    __global__ void init_data_cost_reduce(int level, int rows, int cols, int h)
-    {
-        int x_out = blockIdx.x;
-        int y_out = blockIdx.y % h;
-        int d = (blockIdx.y / h) * blockDim.z + threadIdx.z;
+template <typename T, int winsz, int channels>
+__global__ void init_data_cost_reduce(int level, int rows, int cols, int h)
+{
+    int x_out = blockIdx.x;
+    int y_out = blockIdx.y % h;
+    int d = (blockIdx.y / h) * blockDim.z + threadIdx.z;
 
-        int tid = threadIdx.x;
+    int tid = threadIdx.x;
 
-        if (d < cndisp)
-        {
-            int x0 = x_out << level;
-            int y0 = y_out << level;
+    if (d < cndisp)
+    {
+        int x0 = x_out << level;
+        int y0 = y_out << level;
 
-            int len = min(y0 + winsz, rows) - y0;
+        int len = ::min(y0 + winsz, rows) - y0;
 
-            float val = 0.0f;
-            if (x0 + tid < cols)
+        float val = 0.0f;
+        if (x0 + tid < cols)
+        {
+            if (x0 + tid - d < 0 || d < cth)
+                val = cdata_weight * cmax_data_term * len;
+            else
             {
-                if (x0 + tid - d < 0 || d < cth)
-                    val = cdata_weight * cmax_data_term * len;
-                else
-                {
-                    const uchar* lle =  cleft + y0 * cimg_step + channels * (x0 + tid    );
-                    const uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - d);
+                const uchar* lle =  cleft + y0 * cimg_step + channels * (x0 + tid    );
+                const uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - d);
 
-                    for(int y = 0; y < len; ++y)
-                    {
-                        val += DataCostPerPixel<channels>::compute(lle, lri);
+                for(int y = 0; y < len; ++y)
+                {
+                    val += DataCostPerPixel<channels>::compute(lle, lri);
 
-                        lle += cimg_step;
-                        lri += cimg_step;
-                    }
+                    lle += cimg_step;
+                    lri += cimg_step;
                 }
             }
+        }
 
-            extern __shared__ float smem[];
-            float* dline = smem + winsz * threadIdx.z;
+        extern __shared__ float smem[];
+        float* dline = smem + winsz * threadIdx.z;
 
-            dline[tid] = val;
+        dline[tid] = val;
 
-            __syncthreads();
+        __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(); }
+        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;
+		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];
+        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];
 
-            T* data_cost = (T*)ctemp + y_out * cmsg_step1 + x_out;
+        T* data_cost = (T*)ctemp + y_out * cmsg_step1 + x_out;
 
-            if (tid == 0)
-                data_cost[cdisp_step1 * d] = saturate_cast<T>(dline[0]);
-        }
+        if (tid == 0)
+            data_cost[cdisp_step1 * d] = saturate_cast<T>(dline[0]);
     }
+}
 
 
-    template <typename T>
-    void init_data_cost_caller_(int /*rows*/, int /*cols*/, int h, int w, int level, int /*ndisp*/, int channels, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename T>
+void init_data_cost_caller_(int /*rows*/, int /*cols*/, int h, int w, int level, int /*ndisp*/, int channels, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(w, threads.x);
-        grid.y = divUp(h, threads.y);
+    grid.x = divUp(w, threads.x);
+    grid.y = divUp(h, threads.y);
 
-        switch (channels)
-        {
-        case 1: init_data_cost<T, 1><<<grid, threads, 0, stream>>>(h, w, level); break;
-        case 3: init_data_cost<T, 3><<<grid, threads, 0, stream>>>(h, w, level); break;
-        case 4: init_data_cost<T, 4><<<grid, threads, 0, stream>>>(h, w, level); break;
-        default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
-        }
+    switch (channels)
+    {
+    case 1: init_data_cost<T, 1><<<grid, threads, 0, stream>>>(h, w, level); break;
+    case 3: init_data_cost<T, 3><<<grid, threads, 0, stream>>>(h, w, level); break;
+    case 4: init_data_cost<T, 4><<<grid, threads, 0, stream>>>(h, w, level); break;
+    default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
     }
+}
 
-    template <typename T, int winsz>
-    void init_data_cost_reduce_caller_(int rows, int cols, int h, int w, int level, int ndisp, int channels, cudaStream_t stream)
-    {
-        const int threadsNum = 256;
-        const size_t smem_size = threadsNum * sizeof(float);
+template <typename T, int winsz>
+void init_data_cost_reduce_caller_(int rows, int cols, int h, int w, int level, int ndisp, int channels, cudaStream_t stream)
+{
+    const int threadsNum = 256;
+    const size_t smem_size = threadsNum * sizeof(float);
 
-        dim3 threads(winsz, 1, threadsNum / winsz);
-        dim3 grid(w, h, 1);
-        grid.y *= divUp(ndisp, threads.z);
+    dim3 threads(winsz, 1, threadsNum / winsz);
+    dim3 grid(w, h, 1);
+    grid.y *= divUp(ndisp, threads.z);
 
-        switch (channels)
-        {
-        case 1: init_data_cost_reduce<T, winsz, 1><<<grid, threads, smem_size, stream>>>(level, rows, cols, h); break;
-        case 3: init_data_cost_reduce<T, winsz, 3><<<grid, threads, smem_size, stream>>>(level, rows, cols, h); break;
-        case 4: init_data_cost_reduce<T, winsz, 4><<<grid, threads, smem_size, stream>>>(level, rows, cols, h); break;
-        default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
-        }
+    switch (channels)
+    {
+    case 1: init_data_cost_reduce<T, winsz, 1><<<grid, threads, smem_size, stream>>>(level, rows, cols, h); break;
+    case 3: init_data_cost_reduce<T, winsz, 3><<<grid, threads, smem_size, stream>>>(level, rows, cols, h); break;
+    case 4: init_data_cost_reduce<T, winsz, 4><<<grid, threads, smem_size, stream>>>(level, rows, cols, h); break;
+    default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
     }
+}
 
-    template<class T>
-    void init_data_cost(int rows, int cols, T* disp_selected_pyr, T* data_cost_selected, size_t msg_step,
-                int h, int w, int level, int nr_plane, int ndisp, int channels, bool use_local_init_data_cost, cudaStream_t stream)
-    {
+template<class T>
+void init_data_cost(int rows, int cols, T* disp_selected_pyr, T* data_cost_selected, size_t msg_step,
+            int h, int w, int level, int nr_plane, int ndisp, int channels, bool use_local_init_data_cost, cudaStream_t stream)
+{
 
-        typedef void (*InitDataCostCaller)(int cols, int rows, int w, int h, int level, int ndisp, int channels, cudaStream_t stream);
+    typedef void (*InitDataCostCaller)(int cols, int rows, int w, int h, int level, int ndisp, int channels, cudaStream_t stream);
 
-        static const InitDataCostCaller init_data_cost_callers[] =
-        {
-            init_data_cost_caller_<T>, init_data_cost_caller_<T>, init_data_cost_reduce_caller_<T, 4>,
-            init_data_cost_reduce_caller_<T, 8>, init_data_cost_reduce_caller_<T, 16>, init_data_cost_reduce_caller_<T, 32>,
-            init_data_cost_reduce_caller_<T, 64>, init_data_cost_reduce_caller_<T, 128>, init_data_cost_reduce_caller_<T, 256>
-        };
+    static const InitDataCostCaller init_data_cost_callers[] =
+    {
+        init_data_cost_caller_<T>, init_data_cost_caller_<T>, init_data_cost_reduce_caller_<T, 4>,
+        init_data_cost_reduce_caller_<T, 8>, init_data_cost_reduce_caller_<T, 16>, init_data_cost_reduce_caller_<T, 32>,
+        init_data_cost_reduce_caller_<T, 64>, init_data_cost_reduce_caller_<T, 128>, init_data_cost_reduce_caller_<T, 256>
+    };
 
-        size_t disp_step = msg_step * h;
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step,  sizeof(size_t)) );
+    size_t disp_step = msg_step * h;
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step,  sizeof(size_t)) );
 
-        init_data_cost_callers[level](rows, cols, h, w, level, ndisp, channels, stream);
-        cudaSafeCall( cudaGetLastError() );
+    init_data_cost_callers[level](rows, cols, h, w, level, ndisp, channels, stream);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
 
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(w, threads.x);
-        grid.y = divUp(h, threads.y);
+    grid.x = divUp(w, threads.x);
+    grid.y = divUp(h, threads.y);
 
-        if (use_local_init_data_cost == true)
-            get_first_k_initial_local<<<grid, threads, 0, stream>>> (data_cost_selected, disp_selected_pyr, h, w, nr_plane);
-        else
-            get_first_k_initial_global<<<grid, threads, 0, stream>>>(data_cost_selected, disp_selected_pyr, h, w, nr_plane);
-        
-        cudaSafeCall( cudaGetLastError() );
+    if (use_local_init_data_cost == true)
+        get_first_k_initial_local<<<grid, threads, 0, stream>>> (data_cost_selected, disp_selected_pyr, h, w, nr_plane);
+    else
+        get_first_k_initial_global<<<grid, threads, 0, stream>>>(data_cost_selected, disp_selected_pyr, h, w, nr_plane);
+    
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template void init_data_cost(int rows, int cols, short* disp_selected_pyr, short* data_cost_selected, size_t msg_step,
-                int h, int w, int level, int nr_plane, int ndisp, int channels, bool use_local_init_data_cost, cudaStream_t stream);
+template void init_data_cost(int rows, int cols, short* disp_selected_pyr, short* data_cost_selected, size_t msg_step,
+            int h, int w, int level, int nr_plane, int ndisp, int channels, bool use_local_init_data_cost, cudaStream_t stream);
 
-    template void init_data_cost(int rows, int cols, float* disp_selected_pyr, float* data_cost_selected, size_t msg_step,
-                int h, int w, int level, int nr_plane, int ndisp, int channels, bool use_local_init_data_cost, cudaStream_t stream);
+template void init_data_cost(int rows, int cols, float* disp_selected_pyr, float* data_cost_selected, size_t msg_step,
+            int h, int w, int level, int nr_plane, int ndisp, int channels, bool use_local_init_data_cost, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////
 ////////////////////// compute data cost //////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T, int channels>
-    __global__ void compute_data_cost(const T* selected_disp_pyr, T* data_cost_, int h, int w, int level, int nr_plane)
-    {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
+template <typename T, int channels>
+__global__ void compute_data_cost(const T* selected_disp_pyr, T* data_cost_, int h, int w, int level, int nr_plane)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (y < h && x < w)
-        {
-            int y0 = y << level;
-            int yt = (y + 1) << level;
+    if (y < h && x < w)
+    {
+        int y0 = y << level;
+        int yt = (y + 1) << level;
 
-            int x0 = x << level;
-            int xt = (x + 1) << level;
+        int x0 = x << level;
+        int xt = (x + 1) << level;
 
-            const T* selected_disparity = selected_disp_pyr + y/2 * cmsg_step2 + x/2;
-            T* data_cost = data_cost_ + y * cmsg_step1 + x;
+        const T* selected_disparity = selected_disp_pyr + y/2 * cmsg_step2 + x/2;
+        T* data_cost = data_cost_ + y * cmsg_step1 + x;
 
-            for(int d = 0; d < nr_plane; d++)
+        for(int d = 0; d < nr_plane; d++)
+        {
+            float val = 0.0f;
+            for(int yi = y0; yi < yt; yi++)
             {
-                float val = 0.0f;
-                for(int yi = y0; yi < yt; yi++)
+                for(int xi = x0; xi < xt; xi++)
                 {
-                    for(int xi = x0; xi < xt; xi++)
+                    int sel_disp = selected_disparity[d * cdisp_step2];
+                    int xr = xi - sel_disp;
+
+                    if (xr < 0 || sel_disp < cth)
+                        val += cdata_weight * cmax_data_term;
+                    else
                     {
-                        int sel_disp = selected_disparity[d * cdisp_step2];
-                        int xr = xi - sel_disp;
-
-                        if (xr < 0 || sel_disp < cth)
-                            val += cdata_weight * cmax_data_term;
-                        else
-                        {
-                            const uchar* left_x = cleft + yi * cimg_step + xi * channels;
-                            const uchar* right_x = cright + yi * cimg_step + xr * channels;
-
-                            val += DataCostPerPixel<channels>::compute(left_x, right_x);
-                        }
+                        const uchar* left_x = cleft + yi * cimg_step + xi * channels;
+                        const uchar* right_x = cright + yi * cimg_step + xr * channels;
+
+                        val += DataCostPerPixel<channels>::compute(left_x, right_x);
                     }
                 }
-                data_cost[cdisp_step1 * d] = saturate_cast<T>(val);
             }
+            data_cost[cdisp_step1 * d] = saturate_cast<T>(val);
         }
     }
+}
 
-    template <typename T, int winsz, int channels>
-    __global__ void compute_data_cost_reduce(const T* selected_disp_pyr, T* data_cost_, int level, int rows, int cols, int h, int nr_plane)
-    {
-        int x_out = blockIdx.x;
-        int y_out = blockIdx.y % h;
-        int d = (blockIdx.y / h) * blockDim.z + threadIdx.z;
+template <typename T, int winsz, int channels>
+__global__ void compute_data_cost_reduce(const T* selected_disp_pyr, T* data_cost_, int level, int rows, int cols, int h, int nr_plane)
+{
+    int x_out = blockIdx.x;
+    int y_out = blockIdx.y % h;
+    int d = (blockIdx.y / h) * blockDim.z + threadIdx.z;
 
-        int tid = threadIdx.x;
+    int tid = threadIdx.x;
 
-        const T* selected_disparity = selected_disp_pyr + y_out/2 * cmsg_step2 + x_out/2;
-        T* data_cost = data_cost_ + y_out * cmsg_step1 + x_out;
+    const T* selected_disparity = selected_disp_pyr + y_out/2 * cmsg_step2 + x_out/2;
+    T* data_cost = data_cost_ + y_out * cmsg_step1 + x_out;
 
-        if (d < nr_plane)
-        {
-            int sel_disp = selected_disparity[d * cdisp_step2];
+    if (d < nr_plane)
+    {
+        int sel_disp = selected_disparity[d * cdisp_step2];
 
-            int x0 = x_out << level;
-            int y0 = y_out << level;
+        int x0 = x_out << level;
+        int y0 = y_out << level;
 
-            int len = min(y0 + winsz, rows) - y0;
+        int len = ::min(y0 + winsz, rows) - y0;
 
-            float val = 0.0f;
-            if (x0 + tid < cols)
+        float val = 0.0f;
+        if (x0 + tid < cols)
+        {
+            if (x0 + tid - sel_disp < 0 || sel_disp < cth)
+                val = cdata_weight * cmax_data_term * len;
+            else
             {
-                if (x0 + tid - sel_disp < 0 || sel_disp < cth)
-                    val = cdata_weight * cmax_data_term * len;
-                else
-                {
-                    const uchar* lle =  cleft + y0 * cimg_step + channels * (x0 + tid    );
-                    const uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - sel_disp);
+                const uchar* lle =  cleft + y0 * cimg_step + channels * (x0 + tid    );
+                const uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - sel_disp);
 
-                    for(int y = 0; y < len; ++y)
-                    {
-                        val += DataCostPerPixel<channels>::compute(lle, lri);
+                for(int y = 0; y < len; ++y)
+                {
+                    val += DataCostPerPixel<channels>::compute(lle, lri);
 
-                        lle += cimg_step;
-                        lri += cimg_step;
-                    }
+                    lle += cimg_step;
+                    lri += cimg_step;
                 }
             }
+        }
 
-            extern __shared__ float smem[];
-            float* dline = smem + winsz * threadIdx.z;
+        extern __shared__ float smem[];
+        float* dline = smem + winsz * threadIdx.z;
 
-            dline[tid] = val;
+        dline[tid] = val;
 
-            __syncthreads();
+        __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(); }
+        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;
+		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];
+        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];
 
-            if (tid == 0)
-                data_cost[cdisp_step1 * d] = saturate_cast<T>(dline[0]);
-        }
+        if (tid == 0)
+            data_cost[cdisp_step1 * d] = saturate_cast<T>(dline[0]);
     }
+}
 
-    template <typename T>
-    void compute_data_cost_caller_(const T* disp_selected_pyr, T* data_cost, int /*rows*/, int /*cols*/,
-                                  int h, int w, int level, int nr_plane, int channels, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename T>
+void compute_data_cost_caller_(const T* disp_selected_pyr, T* data_cost, int /*rows*/, int /*cols*/,
+                              int h, int w, int level, int nr_plane, int channels, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(w, threads.x);
-        grid.y = divUp(h, threads.y);
+    grid.x = divUp(w, threads.x);
+    grid.y = divUp(h, threads.y);
 
-        switch(channels)
-        {
-        case 1: compute_data_cost<T, 1><<<grid, threads, 0, stream>>>(disp_selected_pyr, data_cost, h, w, level, nr_plane); break;
-        case 3: compute_data_cost<T, 3><<<grid, threads, 0, stream>>>(disp_selected_pyr, data_cost, h, w, level, nr_plane); break;
-        case 4: compute_data_cost<T, 4><<<grid, threads, 0, stream>>>(disp_selected_pyr, data_cost, h, w, level, nr_plane); break;
-        default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
-        }
+    switch(channels)
+    {
+    case 1: compute_data_cost<T, 1><<<grid, threads, 0, stream>>>(disp_selected_pyr, data_cost, h, w, level, nr_plane); break;
+    case 3: compute_data_cost<T, 3><<<grid, threads, 0, stream>>>(disp_selected_pyr, data_cost, h, w, level, nr_plane); break;
+    case 4: compute_data_cost<T, 4><<<grid, threads, 0, stream>>>(disp_selected_pyr, data_cost, h, w, level, nr_plane); break;
+    default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
     }
+}
 
-    template <typename T, int winsz>
-    void compute_data_cost_reduce_caller_(const T* disp_selected_pyr, T* data_cost, int rows, int cols,
-                                  int h, int w, int level, int nr_plane, int channels, cudaStream_t stream)
-    {
-        const int threadsNum = 256;
-        const size_t smem_size = threadsNum * sizeof(float);
+template <typename T, int winsz>
+void compute_data_cost_reduce_caller_(const T* disp_selected_pyr, T* data_cost, int rows, int cols,
+                              int h, int w, int level, int nr_plane, int channels, cudaStream_t stream)
+{
+    const int threadsNum = 256;
+    const size_t smem_size = threadsNum * sizeof(float);
 
-        dim3 threads(winsz, 1, threadsNum / winsz);
-        dim3 grid(w, h, 1);
-        grid.y *= divUp(nr_plane, threads.z);
+    dim3 threads(winsz, 1, threadsNum / winsz);
+    dim3 grid(w, h, 1);
+    grid.y *= divUp(nr_plane, threads.z);
 
-        switch (channels)
-        {
-        case 1: compute_data_cost_reduce<T, winsz, 1><<<grid, threads, smem_size, stream>>>(disp_selected_pyr, data_cost, level, rows, cols, h, nr_plane); break;
-        case 3: compute_data_cost_reduce<T, winsz, 3><<<grid, threads, smem_size, stream>>>(disp_selected_pyr, data_cost, level, rows, cols, h, nr_plane); break;
-        case 4: compute_data_cost_reduce<T, winsz, 4><<<grid, threads, smem_size, stream>>>(disp_selected_pyr, data_cost, level, rows, cols, h, nr_plane); break;
-        default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
-        }
+    switch (channels)
+    {
+    case 1: compute_data_cost_reduce<T, winsz, 1><<<grid, threads, smem_size, stream>>>(disp_selected_pyr, data_cost, level, rows, cols, h, nr_plane); break;
+    case 3: compute_data_cost_reduce<T, winsz, 3><<<grid, threads, smem_size, stream>>>(disp_selected_pyr, data_cost, level, rows, cols, h, nr_plane); break;
+    case 4: compute_data_cost_reduce<T, winsz, 4><<<grid, threads, smem_size, stream>>>(disp_selected_pyr, data_cost, level, rows, cols, h, nr_plane); break;
+    default: cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
     }
+}
 
-    template<class T>
-    void compute_data_cost(const T* disp_selected_pyr, T* data_cost, size_t msg_step1, size_t msg_step2,
-                           int rows, int cols, int h, int w, int h2, int level, int nr_plane, int channels, cudaStream_t stream)
+template<class T>
+void compute_data_cost(const T* disp_selected_pyr, T* data_cost, size_t msg_step1, size_t msg_step2,
+                       int rows, int cols, int h, int w, int h2, int level, int nr_plane, int channels, cudaStream_t stream)
+{
+    typedef void (*ComputeDataCostCaller)(const T* disp_selected_pyr, T* data_cost, int rows, int cols,
+        int h, int w, int level, int nr_plane, int channels, cudaStream_t stream);
+
+    static const ComputeDataCostCaller callers[] =
     {
-        typedef void (*ComputeDataCostCaller)(const T* disp_selected_pyr, T* data_cost, int rows, int cols,
-            int h, int w, int level, int nr_plane, int channels, cudaStream_t stream);
+        compute_data_cost_caller_<T>, compute_data_cost_caller_<T>, compute_data_cost_reduce_caller_<T, 4>,
+        compute_data_cost_reduce_caller_<T, 8>, compute_data_cost_reduce_caller_<T, 16>, compute_data_cost_reduce_caller_<T, 32>,
+        compute_data_cost_reduce_caller_<T, 64>, compute_data_cost_reduce_caller_<T, 128>, compute_data_cost_reduce_caller_<T, 256>
+    };
 
-        static const ComputeDataCostCaller callers[] =
-        {
-            compute_data_cost_caller_<T>, compute_data_cost_caller_<T>, compute_data_cost_reduce_caller_<T, 4>,
-            compute_data_cost_reduce_caller_<T, 8>, compute_data_cost_reduce_caller_<T, 16>, compute_data_cost_reduce_caller_<T, 32>,
-            compute_data_cost_reduce_caller_<T, 64>, compute_data_cost_reduce_caller_<T, 128>, compute_data_cost_reduce_caller_<T, 256>
-        };
-
-        size_t disp_step1 = msg_step1 * h;
-        size_t disp_step2 = msg_step2 * h2;
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step1, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step2, &disp_step2, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step1,  sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step2,  &msg_step2,  sizeof(size_t)) );
-
-        callers[level](disp_selected_pyr, data_cost, rows, cols, h, w, level, nr_plane, channels, stream);
-        cudaSafeCall( cudaGetLastError() );
+    size_t disp_step1 = msg_step1 * h;
+    size_t disp_step2 = msg_step2 * h2;
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step1, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step2, &disp_step2, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step1,  sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step2,  &msg_step2,  sizeof(size_t)) );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    callers[level](disp_selected_pyr, data_cost, rows, cols, h, w, level, nr_plane, channels, stream);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template void compute_data_cost(const short* disp_selected_pyr, short* data_cost, size_t msg_step1, size_t msg_step2,
-                           int rows, int cols, int h, int w, int h2, int level, int nr_plane, int channels, cudaStream_t stream);
+template void compute_data_cost(const short* disp_selected_pyr, short* data_cost, size_t msg_step1, size_t msg_step2,
+                       int rows, int cols, int h, int w, int h2, int level, int nr_plane, int channels, cudaStream_t stream);
 
-    template void compute_data_cost(const float* disp_selected_pyr, float* data_cost, size_t msg_step1, size_t msg_step2,
-                           int rows, int cols, int h, int w, int h2, int level, int nr_plane, int channels, cudaStream_t stream);
+template void compute_data_cost(const float* disp_selected_pyr, float* data_cost, size_t msg_step1, size_t msg_step2,
+                       int rows, int cols, int h, int w, int h2, int level, int nr_plane, int channels, cudaStream_t stream);
      
 
 ///////////////////////////////////////////////////////////////
@@ -600,229 +597,229 @@ namespace cv { namespace gpu { namespace csbp
 ///////////////////////////////////////////////////////////////
 
  
-     template <typename T>
-    __device__ void get_first_k_element_increase(T* u_new, T* d_new, T* l_new, T* r_new,
-                                                 const T* u_cur, const T* d_cur, const T* l_cur, const T* r_cur,
-                                                 T* data_cost_selected, T* disparity_selected_new, T* data_cost_new,
-                                                 const T* data_cost_cur, const T* disparity_selected_cur,
-                                                 int nr_plane, int nr_plane2)
+ template <typename T>
+__device__ void get_first_k_element_increase(T* u_new, T* d_new, T* l_new, T* r_new,
+                                             const T* u_cur, const T* d_cur, const T* l_cur, const T* r_cur,
+                                             T* data_cost_selected, T* disparity_selected_new, T* data_cost_new,
+                                             const T* data_cost_cur, const T* disparity_selected_cur,
+                                             int nr_plane, int nr_plane2)
+{
+    for(int i = 0; i < nr_plane; i++)
     {
-        for(int i = 0; i < nr_plane; i++)
+        T minimum = numeric_limits<T>::max();
+        int id = 0;
+        for(int j = 0; j < nr_plane2; j++)
         {
-            T minimum = numeric_limits<T>::max();
-            int id = 0;
-            for(int j = 0; j < nr_plane2; j++)
+            T cur = data_cost_new[j * cdisp_step1];
+            if(cur < minimum)
             {
-                T cur = data_cost_new[j * cdisp_step1];
-                if(cur < minimum)
-                {
-                    minimum = cur;
-                    id = j;
-                }
+                minimum = cur;
+                id = j;
             }
+        }
 
-            data_cost_selected[i * cdisp_step1] = data_cost_cur[id * cdisp_step1];
-            disparity_selected_new[i * cdisp_step1] = disparity_selected_cur[id * cdisp_step2];
+        data_cost_selected[i * cdisp_step1] = data_cost_cur[id * cdisp_step1];
+        disparity_selected_new[i * cdisp_step1] = disparity_selected_cur[id * cdisp_step2];
 
-            u_new[i * cdisp_step1] = u_cur[id * cdisp_step2];
-            d_new[i * cdisp_step1] = d_cur[id * cdisp_step2];
-            l_new[i * cdisp_step1] = l_cur[id * cdisp_step2];
-            r_new[i * cdisp_step1] = r_cur[id * cdisp_step2];
+        u_new[i * cdisp_step1] = u_cur[id * cdisp_step2];
+        d_new[i * cdisp_step1] = d_cur[id * cdisp_step2];
+        l_new[i * cdisp_step1] = l_cur[id * cdisp_step2];
+        r_new[i * cdisp_step1] = r_cur[id * cdisp_step2];
 
-            data_cost_new[id * cdisp_step1] = numeric_limits<T>::max();
-        }
+        data_cost_new[id * cdisp_step1] = numeric_limits<T>::max();
     }
-
-    template <typename T>
-    __global__ void init_message(T* u_new_, T* d_new_, T* l_new_, T* r_new_,
-                                 const T* u_cur_, const T* d_cur_, const T* l_cur_, const T* r_cur_,
-                                 T* selected_disp_pyr_new, const T* selected_disp_pyr_cur,
-                                 T* data_cost_selected_, const T* data_cost_,
-                                 int h, int w, int nr_plane, int h2, int w2, int nr_plane2)
+}
+
+template <typename T>
+__global__ void init_message(T* u_new_, T* d_new_, T* l_new_, T* r_new_,
+                             const T* u_cur_, const T* d_cur_, const T* l_cur_, const T* r_cur_,
+                             T* selected_disp_pyr_new, const T* selected_disp_pyr_cur,
+                             T* data_cost_selected_, const T* data_cost_,
+                             int h, int w, int nr_plane, int h2, int w2, int nr_plane2)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y < h && x < w)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (y < h && x < w)
-        {
-            const T* u_cur = u_cur_ + min(h2-1, y/2 + 1) * cmsg_step2 + x/2;
-            const T* d_cur = d_cur_ + max(0, y/2 - 1)    * cmsg_step2 + x/2;
-            const T* l_cur = l_cur_ + y/2                * cmsg_step2 + min(w2-1, x/2 + 1);
-            const T* r_cur = r_cur_ + y/2                * cmsg_step2 + max(0, x/2 - 1);
+        const T* u_cur = u_cur_ + ::min(h2-1, y/2 + 1) * cmsg_step2 + x/2;
+        const T* d_cur = d_cur_ + ::max(0, y/2 - 1)    * cmsg_step2 + x/2;
+        const T* l_cur = l_cur_ + y/2                  * cmsg_step2 + ::min(w2-1, x/2 + 1);
+        const T* r_cur = r_cur_ + y/2                  * cmsg_step2 + ::max(0, x/2 - 1);
 
-            T* data_cost_new = (T*)ctemp + y * cmsg_step1 + x;
+        T* data_cost_new = (T*)ctemp + y * cmsg_step1 + x;
 
-            const T* disparity_selected_cur = selected_disp_pyr_cur + y/2 * cmsg_step2 + x/2;
-            const T* data_cost = data_cost_ + y * cmsg_step1 + x;
+        const T* disparity_selected_cur = selected_disp_pyr_cur + y/2 * cmsg_step2 + x/2;
+        const T* data_cost = data_cost_ + y * cmsg_step1 + x;
 
-            for(int d = 0; d < nr_plane2; d++)
-            {
-                int idx2 = d * cdisp_step2;
-
-                T val  = data_cost[d * cdisp_step1] + u_cur[idx2] + d_cur[idx2] + l_cur[idx2] + r_cur[idx2];
-                data_cost_new[d * cdisp_step1] = val;
-            }
-
-            T* data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x;
-            T* disparity_selected_new = selected_disp_pyr_new + y * cmsg_step1 + x;
-
-            T* u_new = u_new_ + y * cmsg_step1 + x;
-            T* d_new = d_new_ + y * cmsg_step1 + x;
-            T* l_new = l_new_ + y * cmsg_step1 + x;
-            T* r_new = r_new_ + y * cmsg_step1 + x;
-
-            u_cur = u_cur_ + y/2 * cmsg_step2 + x/2;
-            d_cur = d_cur_ + y/2 * cmsg_step2 + x/2;
-            l_cur = l_cur_ + y/2 * cmsg_step2 + x/2;
-            r_cur = r_cur_ + y/2 * cmsg_step2 + x/2;
+        for(int d = 0; d < nr_plane2; d++)
+        {
+            int idx2 = d * cdisp_step2;
 
-            get_first_k_element_increase(u_new, d_new, l_new, r_new, u_cur, d_cur, l_cur, r_cur,
-                                         data_cost_selected, disparity_selected_new, data_cost_new,
-                                         data_cost, disparity_selected_cur, nr_plane, nr_plane2);
+            T val  = data_cost[d * cdisp_step1] + u_cur[idx2] + d_cur[idx2] + l_cur[idx2] + r_cur[idx2];
+            data_cost_new[d * cdisp_step1] = val;
         }
-    }
-
-
-    template<class T>
-    void init_message(T* u_new, T* d_new, T* l_new, T* r_new,
-                      const T* u_cur, const T* d_cur, const T* l_cur, const T* r_cur,
-                      T* selected_disp_pyr_new, const T* selected_disp_pyr_cur,
-                      T* data_cost_selected, const T* data_cost, size_t msg_step1, size_t msg_step2,
-                      int h, int w, int nr_plane, int h2, int w2, int nr_plane2, cudaStream_t stream)
-    {
 
-        size_t disp_step1 = msg_step1 * h;
-        size_t disp_step2 = msg_step2 * h2;
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step1, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step2, &disp_step2, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,   &msg_step1, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step2,   &msg_step2, sizeof(size_t)) );
+        T* data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x;
+        T* disparity_selected_new = selected_disp_pyr_new + y * cmsg_step1 + x;
 
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+        T* u_new = u_new_ + y * cmsg_step1 + x;
+        T* d_new = d_new_ + y * cmsg_step1 + x;
+        T* l_new = l_new_ + y * cmsg_step1 + x;
+        T* r_new = r_new_ + y * cmsg_step1 + x;
 
-        grid.x = divUp(w, threads.x);
-        grid.y = divUp(h, threads.y);
+        u_cur = u_cur_ + y/2 * cmsg_step2 + x/2;
+        d_cur = d_cur_ + y/2 * cmsg_step2 + x/2;
+        l_cur = l_cur_ + y/2 * cmsg_step2 + x/2;
+        r_cur = r_cur_ + y/2 * cmsg_step2 + x/2;
 
-        init_message<<<grid, threads, 0, stream>>>(u_new, d_new, l_new, r_new,
-                                                   u_cur, d_cur, l_cur, r_cur,
-                                                   selected_disp_pyr_new, selected_disp_pyr_cur,
-                                                   data_cost_selected, data_cost,
-                                                   h, w, nr_plane, h2, w2, nr_plane2);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        get_first_k_element_increase(u_new, d_new, l_new, r_new, u_cur, d_cur, l_cur, r_cur,
+                                     data_cost_selected, disparity_selected_new, data_cost_new,
+                                     data_cost, disparity_selected_cur, nr_plane, nr_plane2);
     }
-
-
-    template void init_message(short* u_new, short* d_new, short* l_new, short* r_new,
-                      const short* u_cur, const short* d_cur, const short* l_cur, const short* r_cur,
-                      short* selected_disp_pyr_new, const short* selected_disp_pyr_cur,
-                      short* data_cost_selected, const short* data_cost, size_t msg_step1, size_t msg_step2,
-                      int h, int w, int nr_plane, int h2, int w2, int nr_plane2, cudaStream_t stream);
-
-    template void init_message(float* u_new, float* d_new, float* l_new, float* r_new,
-                      const float* u_cur, const float* d_cur, const float* l_cur, const float* r_cur,
-                      float* selected_disp_pyr_new, const float* selected_disp_pyr_cur,
-                      float* data_cost_selected, const float* data_cost, size_t msg_step1, size_t msg_step2,
-                      int h, int w, int nr_plane, int h2, int w2, int nr_plane2, cudaStream_t stream);        
+}
+
+
+template<class T>
+void init_message(T* u_new, T* d_new, T* l_new, T* r_new,
+                  const T* u_cur, const T* d_cur, const T* l_cur, const T* r_cur,
+                  T* selected_disp_pyr_new, const T* selected_disp_pyr_cur,
+                  T* data_cost_selected, const T* data_cost, size_t msg_step1, size_t msg_step2,
+                  int h, int w, int nr_plane, int h2, int w2, int nr_plane2, cudaStream_t stream)
+{
+
+    size_t disp_step1 = msg_step1 * h;
+    size_t disp_step2 = msg_step2 * h2;
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step1, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step2, &disp_step2, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,   &msg_step1, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step2,   &msg_step2, sizeof(size_t)) );
+
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+
+    grid.x = divUp(w, threads.x);
+    grid.y = divUp(h, threads.y);
+
+    init_message<<<grid, threads, 0, stream>>>(u_new, d_new, l_new, r_new,
+                                               u_cur, d_cur, l_cur, r_cur,
+                                               selected_disp_pyr_new, selected_disp_pyr_cur,
+                                               data_cost_selected, data_cost,
+                                               h, w, nr_plane, h2, w2, nr_plane2);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+
+template void init_message(short* u_new, short* d_new, short* l_new, short* r_new,
+                  const short* u_cur, const short* d_cur, const short* l_cur, const short* r_cur,
+                  short* selected_disp_pyr_new, const short* selected_disp_pyr_cur,
+                  short* data_cost_selected, const short* data_cost, size_t msg_step1, size_t msg_step2,
+                  int h, int w, int nr_plane, int h2, int w2, int nr_plane2, cudaStream_t stream);
+
+template void init_message(float* u_new, float* d_new, float* l_new, float* r_new,
+                  const float* u_cur, const float* d_cur, const float* l_cur, const float* r_cur,
+                  float* selected_disp_pyr_new, const float* selected_disp_pyr_cur,
+                  float* data_cost_selected, const float* data_cost, size_t msg_step1, size_t msg_step2,
+                  int h, int w, int nr_plane, int h2, int w2, int nr_plane2, cudaStream_t stream);        
 
 ///////////////////////////////////////////////////////////////
 ////////////////////  calc all iterations /////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __device__ void message_per_pixel(const T* data, T* msg_dst, const T* msg1, const T* msg2, const T* msg3,
-                                      const T* dst_disp, const T* src_disp, int nr_plane, T* temp)
+template <typename T>
+__device__ void message_per_pixel(const T* data, T* msg_dst, const T* msg1, const T* msg2, const T* msg3,
+                                  const T* dst_disp, const T* src_disp, int nr_plane, T* temp)
+{
+    T minimum = numeric_limits<T>::max();
+
+    for(int d = 0; d < nr_plane; d++)
     {
-        T minimum = numeric_limits<T>::max();
+        int idx = d * cdisp_step1;
+        T val  = data[idx] + msg1[idx] + msg2[idx] + msg3[idx];
 
-        for(int d = 0; d < nr_plane; d++)
-        {
-            int idx = d * cdisp_step1;
-            T val  = data[idx] + msg1[idx] + msg2[idx] + msg3[idx];
+        if(val < minimum)
+            minimum = val;
 
-            if(val < minimum)
-                minimum = val;
+        msg_dst[idx] = val;
+    }
 
-            msg_dst[idx] = val;
-        }
+    float sum = 0;
+    for(int d = 0; d < nr_plane; d++)
+    {
+        float cost_min = minimum + cmax_disc_term;
+        T src_disp_reg = src_disp[d * cdisp_step1];
 
-        float sum = 0;
-        for(int d = 0; d < nr_plane; d++)
-        {
-            float cost_min = minimum + cmax_disc_term;
-            T src_disp_reg = src_disp[d * cdisp_step1];
+        for(int d2 = 0; d2 < nr_plane; d2++)
+            cost_min = fmin(cost_min, msg_dst[d2 * cdisp_step1] + cdisc_single_jump * ::abs(dst_disp[d2 * cdisp_step1] - src_disp_reg));
 
-            for(int d2 = 0; d2 < nr_plane; d2++)
-                cost_min = fmin(cost_min, msg_dst[d2 * cdisp_step1] + cdisc_single_jump * abs(dst_disp[d2 * cdisp_step1] - src_disp_reg));
+        temp[d * cdisp_step1] = saturate_cast<T>(cost_min);
+        sum += cost_min;
+    }
+    sum /= nr_plane;
 
-            temp[d * cdisp_step1] = saturate_cast<T>(cost_min);
-            sum += cost_min;
-        }
-        sum /= nr_plane;
+    for(int d = 0; d < nr_plane; d++)
+        msg_dst[d * cdisp_step1] = saturate_cast<T>(temp[d * cdisp_step1] - sum);
+}
 
-        for(int d = 0; d < nr_plane; d++)
-            msg_dst[d * cdisp_step1] = saturate_cast<T>(temp[d * cdisp_step1] - sum);
-    }
+template <typename T>
+__global__ void compute_message(T* u_, T* d_, T* l_, T* r_, const T* data_cost_selected, const T* selected_disp_pyr_cur, int h, int w, int nr_plane, int i)
+{
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + i) & 1);
 
-    template <typename T>
-    __global__ void compute_message(T* u_, T* d_, T* l_, T* r_, const T* data_cost_selected, const T* selected_disp_pyr_cur, int h, int w, int nr_plane, int i)
+    if (y > 0 && y < h - 1 && x > 0 && x < w - 1)
     {
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
-        int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + i) & 1);
-
-        if (y > 0 && y < h - 1 && x > 0 && x < w - 1)
-        {
-            const T* data = data_cost_selected + y * cmsg_step1 + x;
+        const T* data = data_cost_selected + y * cmsg_step1 + x;
 
-            T* u = u_ + y * cmsg_step1 + x;
-            T* d = d_ + y * cmsg_step1 + x;
-            T* l = l_ + y * cmsg_step1 + x;
-            T* r = r_ + y * cmsg_step1 + x;
+        T* u = u_ + y * cmsg_step1 + x;
+        T* d = d_ + y * cmsg_step1 + x;
+        T* l = l_ + y * cmsg_step1 + x;
+        T* r = r_ + y * cmsg_step1 + x;
 
-            const T* disp = selected_disp_pyr_cur + y * cmsg_step1 + x;
+        const T* disp = selected_disp_pyr_cur + y * cmsg_step1 + x;
 
-            T* temp = (T*)ctemp + y * cmsg_step1 + x;
+        T* temp = (T*)ctemp + y * cmsg_step1 + x;
 
-            message_per_pixel(data, u, r - 1, u + cmsg_step1, l + 1, disp, disp - cmsg_step1, nr_plane, temp);
-            message_per_pixel(data, d, d - cmsg_step1, r - 1, l + 1, disp, disp + cmsg_step1, nr_plane, temp);
-            message_per_pixel(data, l, u + cmsg_step1, d - cmsg_step1, l + 1, disp, disp - 1, nr_plane, temp);
-            message_per_pixel(data, r, u + cmsg_step1, d - cmsg_step1, r - 1, disp, disp + 1, nr_plane, temp);
-        }
+        message_per_pixel(data, u, r - 1, u + cmsg_step1, l + 1, disp, disp - cmsg_step1, nr_plane, temp);
+        message_per_pixel(data, d, d - cmsg_step1, r - 1, l + 1, disp, disp + cmsg_step1, nr_plane, temp);
+        message_per_pixel(data, l, u + cmsg_step1, d - cmsg_step1, l + 1, disp, disp - 1, nr_plane, temp);
+        message_per_pixel(data, r, u + cmsg_step1, d - cmsg_step1, r - 1, disp, disp + 1, nr_plane, temp);
     }
+}
 
 
-    template<class T>
-    void calc_all_iterations(T* u, T* d, T* l, T* r, const T* data_cost_selected,
-        const T* selected_disp_pyr_cur, size_t msg_step, int h, int w, int nr_plane, int iters, cudaStream_t stream)
-    {
-        size_t disp_step = msg_step * h;
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step,  sizeof(size_t)) );
+template<class T>
+void calc_all_iterations(T* u, T* d, T* l, T* r, const T* data_cost_selected,
+    const T* selected_disp_pyr_cur, size_t msg_step, int h, int w, int nr_plane, int iters, cudaStream_t stream)
+{
+    size_t disp_step = msg_step * h;
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step,  sizeof(size_t)) );
 
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(w, threads.x << 1);
-        grid.y = divUp(h, threads.y);
+    grid.x = divUp(w, threads.x << 1);
+    grid.y = divUp(h, threads.y);
 
-        for(int t = 0; t < iters; ++t)
-        {
-            compute_message<<<grid, threads, 0, stream>>>(u, d, l, r, data_cost_selected, selected_disp_pyr_cur, h, w, nr_plane, t & 1);
-            cudaSafeCall( cudaGetLastError() );
+    for(int t = 0; t < iters; ++t)
+    {
+        compute_message<<<grid, threads, 0, stream>>>(u, d, l, r, data_cost_selected, selected_disp_pyr_cur, h, w, nr_plane, t & 1);
+        cudaSafeCall( cudaGetLastError() );
 
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    
-    template void calc_all_iterations(short* u, short* d, short* l, short* r, const short* data_cost_selected, const short* selected_disp_pyr_cur, size_t msg_step,
-        int h, int w, int nr_plane, int iters, cudaStream_t stream);
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
 
-    template void calc_all_iterations(float* u, float* d, float* l, float* r, const float* data_cost_selected, const float* selected_disp_pyr_cur, size_t msg_step, 
-        int h, int w, int nr_plane, int iters, cudaStream_t stream);
+template void calc_all_iterations(short* u, short* d, short* l, short* r, const short* data_cost_selected, const short* selected_disp_pyr_cur, size_t msg_step,
+    int h, int w, int nr_plane, int iters, cudaStream_t stream);
+
+template void calc_all_iterations(float* u, float* d, float* l, float* r, const float* data_cost_selected, const float* selected_disp_pyr_cur, size_t msg_step, 
+    int h, int w, int nr_plane, int iters, cudaStream_t stream);
 
 
 ///////////////////////////////////////////////////////////////
@@ -830,66 +827,69 @@ namespace cv { namespace gpu { namespace csbp
 ///////////////////////////////////////////////////////////////
 
 
-    template <typename T>
-    __global__ void compute_disp(const T* u_, const T* d_, const T* l_, const T* r_,
-                                 const T* data_cost_selected, const T* disp_selected_pyr,
-                                 short* disp, size_t res_step, int cols, int rows, int nr_plane)
+template <typename T>
+__global__ void compute_disp(const T* u_, const T* d_, const T* l_, const T* r_,
+                             const T* data_cost_selected, const T* disp_selected_pyr,
+                             short* disp, size_t res_step, int cols, int rows, int nr_plane)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y > 0 && y < rows - 1 && x > 0 && x < cols - 1)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const T* data = data_cost_selected + y * cmsg_step1 + x;
+        const T* disp_selected = disp_selected_pyr + y * cmsg_step1 + x;
 
-        if (y > 0 && y < rows - 1 && x > 0 && x < cols - 1)
-        {
-            const T* data = data_cost_selected + y * cmsg_step1 + x;
-            const T* disp_selected = disp_selected_pyr + y * cmsg_step1 + x;
+        const T* u = u_ + (y+1) * cmsg_step1 + (x+0);
+        const T* d = d_ + (y-1) * cmsg_step1 + (x+0);
+        const T* l = l_ + (y+0) * cmsg_step1 + (x+1);
+        const T* r = r_ + (y+0) * cmsg_step1 + (x-1);
 
-            const T* u = u_ + (y+1) * cmsg_step1 + (x+0);
-            const T* d = d_ + (y-1) * cmsg_step1 + (x+0);
-            const T* l = l_ + (y+0) * cmsg_step1 + (x+1);
-            const T* r = r_ + (y+0) * cmsg_step1 + (x-1);
+        int best = 0;
+        T best_val = numeric_limits<T>::max();
+        for (int i = 0; i < nr_plane; ++i)
+        {
+            int idx = i * cdisp_step1;
+            T val = data[idx]+ u[idx] + d[idx] + l[idx] + r[idx];
 
-            int best = 0;
-            T best_val = numeric_limits<T>::max();
-            for (int i = 0; i < nr_plane; ++i)
+            if (val < best_val)
             {
-                int idx = i * cdisp_step1;
-                T val = data[idx]+ u[idx] + d[idx] + l[idx] + r[idx];
-
-                if (val < best_val)
-                {
-                    best_val = val;
-                    best = saturate_cast<short>(disp_selected[idx]);
-                }
+                best_val = val;
+                best = saturate_cast<short>(disp_selected[idx]);
             }
-            disp[res_step * y + x] = best;
         }
+        disp[res_step * y + x] = best;
     }
+}
 
-    template<class T>
-    void compute_disp(const T* u, const T* d, const T* l, const T* r, const T* data_cost_selected, const T* disp_selected, size_t msg_step,
-        const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream)
-    {
-        size_t disp_step = disp.rows * msg_step;
-        cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step, sizeof(size_t)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step,  sizeof(size_t)) );
+template<class T>
+void compute_disp(const T* u, const T* d, const T* l, const T* r, const T* data_cost_selected, const T* disp_selected, size_t msg_step,
+    const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream)
+{
+    size_t disp_step = disp.rows * msg_step;
+    cudaSafeCall( cudaMemcpyToSymbol(cdisp_step1, &disp_step, sizeof(size_t)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmsg_step1,  &msg_step,  sizeof(size_t)) );
 
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(disp.cols, threads.x);
-        grid.y = divUp(disp.rows, threads.y);
+    grid.x = divUp(disp.cols, threads.x);
+    grid.y = divUp(disp.rows, threads.y);
 
-        compute_disp<<<grid, threads, 0, stream>>>(u, d, l, r, data_cost_selected, disp_selected,
-                                                   disp.data, disp.step / disp.elemSize(), disp.cols, disp.rows, nr_plane);
-        cudaSafeCall( cudaGetLastError() );
+    compute_disp<<<grid, threads, 0, stream>>>(u, d, l, r, data_cost_selected, disp_selected,
+                                               disp.data, disp.step / disp.elemSize(), disp.cols, disp.rows, nr_plane);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template void compute_disp(const short* u, const short* d, const short* l, const short* r, const short* data_cost_selected, const short* disp_selected, size_t msg_step, 
+    const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream);
+
+template void compute_disp(const float* u, const float* d, const float* l, const float* r, const float* data_cost_selected, const float* disp_selected, size_t msg_step,
+    const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream);
 
-    template void compute_disp(const short* u, const short* d, const short* l, const short* r, const short* data_cost_selected, const short* disp_selected, size_t msg_step, 
-        const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream);
+} // namespace stereocsbp
 
-    template void compute_disp(const float* u, const float* d, const float* l, const float* r, const float* data_cost_selected, const float* disp_selected, size_t msg_step,
-        const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cuda/surf.cu b/modules/gpu/src/cuda/surf.cu
index a6f26fd3ec42b245dba1bf93706374cf0507c82e..afd81a6621ce963dda0602b99178bd42a2a543a6 100644
--- a/modules/gpu/src/cuda/surf.cu
+++ b/modules/gpu/src/cuda/surf.cu
@@ -52,930 +52,951 @@
 #include "opencv2/gpu/device/functional.hpp"
 #include "opencv2/gpu/device/filters.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace surf {
+
+////////////////////////////////////////////////////////////////////////
+// Global parameters
+
+// The maximum number of features (before subpixel interpolation) that memory is reserved for.
+__constant__ int c_max_candidates;
+// The maximum number of features that memory is reserved for.
+__constant__ int c_max_features;
+// The image size.
+__constant__ int c_img_rows;
+__constant__ int c_img_cols;
+// The number of layers.
+__constant__ int c_nOctaveLayers;
+// The hessian threshold.
+__constant__ float c_hessianThreshold;
+
+// The current octave.
+__constant__ int c_octave;
+// The current layer size.
+__constant__ int c_layer_rows;
+__constant__ int c_layer_cols;
+
+void loadGlobalConstants(int maxCandidates, int maxFeatures, int img_rows, int img_cols, int nOctaveLayers, float hessianThreshold)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(c_max_candidates, &maxCandidates, sizeof(maxCandidates)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_max_features, &maxFeatures, sizeof(maxFeatures)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_img_rows, &img_rows, sizeof(img_rows)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_img_cols, &img_cols, sizeof(img_cols)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_nOctaveLayers, &nOctaveLayers, sizeof(nOctaveLayers)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_hessianThreshold, &hessianThreshold, sizeof(hessianThreshold)) );
+}
+
+void loadOctaveConstants(int octave, int layer_rows, int layer_cols)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(c_octave, &octave, sizeof(octave)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_layer_rows, &layer_rows, sizeof(layer_rows)) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_layer_cols, &layer_cols, sizeof(layer_cols)) );
+}
 
-#define CV_PI 3.1415926535897932384626433832795f
+////////////////////////////////////////////////////////////////////////
+// Integral image texture
 
-namespace cv { namespace gpu { namespace surf
+texture<unsigned char, 2, cudaReadModeElementType> imgTex(0, cudaFilterModePoint, cudaAddressModeClamp);
+texture<unsigned int, 2, cudaReadModeElementType> sumTex(0, cudaFilterModePoint, cudaAddressModeClamp);
+texture<unsigned int, 2, cudaReadModeElementType> maskSumTex(0, cudaFilterModePoint, cudaAddressModeClamp);
+
+void bindImgTex(DevMem2Db img)
 {
-    ////////////////////////////////////////////////////////////////////////
-    // Global parameters
-
-    // The maximum number of features (before subpixel interpolation) that memory is reserved for.
-    __constant__ int c_max_candidates;
-    // The maximum number of features that memory is reserved for.
-    __constant__ int c_max_features;
-    // The image size.
-    __constant__ int c_img_rows;
-    __constant__ int c_img_cols;
-    // The number of layers.
-    __constant__ int c_nOctaveLayers;
-    // The hessian threshold.
-    __constant__ float c_hessianThreshold;
-
-    // The current octave.
-    __constant__ int c_octave;
-    // The current layer size.
-    __constant__ int c_layer_rows;
-    __constant__ int c_layer_cols;
-
-    ////////////////////////////////////////////////////////////////////////
-    // Integral image texture
-
-    texture<unsigned int, 2, cudaReadModeElementType> sumTex(0, cudaFilterModePoint, cudaAddressModeClamp);
-    texture<unsigned int, 2, cudaReadModeElementType> maskSumTex(0, cudaFilterModePoint, cudaAddressModeClamp);
-
-    template <int N> __device__ float icvCalcHaarPatternSum(const float src[][5], int oldSize, int newSize, int y, int x)
-    {
-        #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
-        typedef double real_t;        
-        #else
-        typedef float  real_t;
-        #endif
+    bindTexture(&imgTex, img);
+}
+void bindSumTex(DevMem2D_<uint> sum)
+{
+    bindTexture(&sumTex, sum);
+}
+void bindMaskSumTex(DevMem2D_<uint> maskSum)
+{
+    bindTexture(&maskSumTex, maskSum);
+}
 
-        float ratio = (float)newSize / oldSize;
-        
-        real_t d = 0;
+template <int N> __device__ float icvCalcHaarPatternSum(const float src[][5], int oldSize, int newSize, int y, int x)
+{
+#if __CUDA_ARCH__ >= 200
+    typedef double real_t;        
+#else
+    typedef float  real_t;
+#endif
 
-        #pragma unroll
-        for (int k = 0; k < N; ++k)
-        {
-            int dx1 = __float2int_rn(ratio * src[k][0]);
-            int dy1 = __float2int_rn(ratio * src[k][1]);
-            int dx2 = __float2int_rn(ratio * src[k][2]);
-            int dy2 = __float2int_rn(ratio * src[k][3]);
-
-            real_t t = 0;
-            t += tex2D(sumTex, x + dx1, y + dy1);
-            t -= tex2D(sumTex, x + dx1, y + dy2);
-            t -= tex2D(sumTex, x + dx2, y + dy1);
-            t += tex2D(sumTex, x + dx2, y + dy2);
-
-            d += t * src[k][4] / ((dx2 - dx1) * (dy2 - dy1));
-        }
+    float ratio = (float)newSize / oldSize;
+    
+    real_t d = 0;
 
-        return (float)d;
+    #pragma unroll
+    for (int k = 0; k < N; ++k)
+    {
+        int dx1 = __float2int_rn(ratio * src[k][0]);
+        int dy1 = __float2int_rn(ratio * src[k][1]);
+        int dx2 = __float2int_rn(ratio * src[k][2]);
+        int dy2 = __float2int_rn(ratio * src[k][3]);
+
+        real_t t = 0;
+        t += tex2D(sumTex, x + dx1, y + dy1);
+        t -= tex2D(sumTex, x + dx1, y + dy2);
+        t -= tex2D(sumTex, x + dx2, y + dy1);
+        t += tex2D(sumTex, x + dx2, y + dy2);
+
+        d += t * src[k][4] / ((dx2 - dx1) * (dy2 - dy1));
     }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Hessian
+    return (float)d;
+}
 
-    __constant__ float c_DX [3][5] = { {0, 2, 3, 7, 1}, {3, 2, 6, 7, -2}, {6, 2, 9, 7, 1} };
-    __constant__ float c_DY [3][5] = { {2, 0, 7, 3, 1}, {2, 3, 7, 6, -2}, {2, 6, 7, 9, 1} };
-    __constant__ float c_DXY[4][5] = { {1, 1, 4, 4, 1}, {5, 1, 8, 4, -1}, {1, 5, 4, 8, -1}, {5, 5, 8, 8, 1} };
+////////////////////////////////////////////////////////////////////////
+// Hessian
 
-    __host__ __device__ __forceinline__ int calcSize(int octave, int layer)
-    {
-        /* Wavelet size at first layer of first octave. */
-        const int HAAR_SIZE0 = 9;
+__constant__ float c_DX [3][5] = { {0, 2, 3, 7, 1}, {3, 2, 6, 7, -2}, {6, 2, 9, 7, 1} };
+__constant__ float c_DY [3][5] = { {2, 0, 7, 3, 1}, {2, 3, 7, 6, -2}, {2, 6, 7, 9, 1} };
+__constant__ float c_DXY[4][5] = { {1, 1, 4, 4, 1}, {5, 1, 8, 4, -1}, {1, 5, 4, 8, -1}, {5, 5, 8, 8, 1} };
+
+__host__ __device__ __forceinline__ int calcSize(int octave, int layer)
+{
+    /* Wavelet size at first layer of first octave. */
+    const int HAAR_SIZE0 = 9;
 
-        /* Wavelet size increment between layers. This should be an even number,
-         such that the wavelet sizes in an octave are either all even or all odd.
-         This ensures that when looking for the neighbours of a sample, the layers
-         above and below are aligned correctly. */
-        const int HAAR_SIZE_INC = 6;
+    /* Wavelet size increment between layers. This should be an even number,
+     such that the wavelet sizes in an octave are either all even or all odd.
+     This ensures that when looking for the neighbours of a sample, the layers
+     above and below are aligned correctly. */
+    const int HAAR_SIZE_INC = 6;
 
-        return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
-    }
+    return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
+}
 
-    __global__ void icvCalcLayerDetAndTrace(PtrStepf det, PtrStepf trace)
-    {
-        // Determine the indices
-        const int gridDim_y = gridDim.y / (c_nOctaveLayers + 2);
-        const int blockIdx_y = blockIdx.y % gridDim_y;
-        const int blockIdx_z = blockIdx.y / gridDim_y;
+__global__ void icvCalcLayerDetAndTrace(PtrStepf det, PtrStepf trace)
+{
+    // Determine the indices
+    const int gridDim_y = gridDim.y / (c_nOctaveLayers + 2);
+    const int blockIdx_y = blockIdx.y % gridDim_y;
+    const int blockIdx_z = blockIdx.y / gridDim_y;
 
-        const int j = threadIdx.x + blockIdx.x * blockDim.x;
-        const int i = threadIdx.y + blockIdx_y * blockDim.y;
-        const int layer = blockIdx_z;
+    const int j = threadIdx.x + blockIdx.x * blockDim.x;
+    const int i = threadIdx.y + blockIdx_y * blockDim.y;
+    const int layer = blockIdx_z;
 
-        const int size = calcSize(c_octave, layer);
+    const int size = calcSize(c_octave, layer);
 
-        const int samples_i = 1 + ((c_img_rows - size) >> c_octave);
-        const int samples_j = 1 + ((c_img_cols - size) >> c_octave);
+    const int samples_i = 1 + ((c_img_rows - size) >> c_octave);
+    const int samples_j = 1 + ((c_img_cols - size) >> c_octave);
 
-        // Ignore pixels where some of the kernel is outside the image
-        const int margin = (size >> 1) >> c_octave;
+    // Ignore pixels where some of the kernel is outside the image
+    const int margin = (size >> 1) >> c_octave;
 
-        if (size <= c_img_rows && size <= c_img_cols && i < samples_i && j < samples_j)
-        {
-            const float dx  = icvCalcHaarPatternSum<3>(c_DX , 9, size, i << c_octave, j << c_octave);
-            const float dy  = icvCalcHaarPatternSum<3>(c_DY , 9, size, i << c_octave, j << c_octave);
-            const float dxy = icvCalcHaarPatternSum<4>(c_DXY, 9, size, i << c_octave, j << c_octave);
+    if (size <= c_img_rows && size <= c_img_cols && i < samples_i && j < samples_j)
+    {
+        const float dx  = icvCalcHaarPatternSum<3>(c_DX , 9, size, i << c_octave, j << c_octave);
+        const float dy  = icvCalcHaarPatternSum<3>(c_DY , 9, size, i << c_octave, j << c_octave);
+        const float dxy = icvCalcHaarPatternSum<4>(c_DXY, 9, size, i << c_octave, j << c_octave);
 
-            det.ptr(layer * c_layer_rows + i + margin)[j + margin] = dx * dy - 0.81f * dxy * dxy;
-            trace.ptr(layer * c_layer_rows + i + margin)[j + margin] = dx + dy;
-        }
+        det.ptr(layer * c_layer_rows + i + margin)[j + margin] = dx * dy - 0.81f * dxy * dxy;
+        trace.ptr(layer * c_layer_rows + i + margin)[j + margin] = dx + dy;
     }
+}
 
-    void icvCalcLayerDetAndTrace_gpu(const PtrStepf& det, const PtrStepf& trace, int img_rows, int img_cols, int octave, int nOctaveLayers)
-    {
-        const int min_size = calcSize(octave, 0);
-        const int max_samples_i = 1 + ((img_rows - min_size) >> octave);
-        const int max_samples_j = 1 + ((img_cols - min_size) >> octave);
+void icvCalcLayerDetAndTrace_gpu(const PtrStepf& det, const PtrStepf& trace, int img_rows, int img_cols, int octave, int nOctaveLayers)
+{
+    const int min_size = calcSize(octave, 0);
+    const int max_samples_i = 1 + ((img_rows - min_size) >> octave);
+    const int max_samples_j = 1 + ((img_cols - min_size) >> octave);
 
-        dim3 threads(16, 16);
+    dim3 threads(16, 16);
 
-        dim3 grid;
-        grid.x = divUp(max_samples_j, threads.x);
-        grid.y = divUp(max_samples_i, threads.y) * (nOctaveLayers + 2);
+    dim3 grid;
+    grid.x = divUp(max_samples_j, threads.x);
+    grid.y = divUp(max_samples_i, threads.y) * (nOctaveLayers + 2);
 
-        icvCalcLayerDetAndTrace<<<grid, threads>>>(det, trace);
-        cudaSafeCall( cudaGetLastError() );
+    icvCalcLayerDetAndTrace<<<grid, threads>>>(det, trace);
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    ////////////////////////////////////////////////////////////////////////
-    // NONMAX
-    
-    struct WithOutMask
-    {
-        static __device__ __forceinline__ bool check(int, int, int)
-        {
-            return true;
-        }
-    };
+////////////////////////////////////////////////////////////////////////
+// NONMAX
 
-    __constant__ float c_DM[5] = {0, 0, 9, 9, 1};
+__constant__ float c_DM[5] = {0, 0, 9, 9, 1};
 
-    struct WithMask
+struct WithMask
+{
+    static __device__ bool check(int sum_i, int sum_j, int size)
     {
-        static __device__ bool check(int sum_i, int sum_j, int size)
-        {
-            float ratio = (float)size / 9.0f;
-            
-            float d = 0;
+        float ratio = (float)size / 9.0f;
+        
+        float d = 0;
 
-            int dx1 = __float2int_rn(ratio * c_DM[0]);
-            int dy1 = __float2int_rn(ratio * c_DM[1]);
-            int dx2 = __float2int_rn(ratio * c_DM[2]);
-            int dy2 = __float2int_rn(ratio * c_DM[3]);
+        int dx1 = __float2int_rn(ratio * c_DM[0]);
+        int dy1 = __float2int_rn(ratio * c_DM[1]);
+        int dx2 = __float2int_rn(ratio * c_DM[2]);
+        int dy2 = __float2int_rn(ratio * c_DM[3]);
 
-            float t = 0;
-            t += tex2D(maskSumTex, sum_j + dx1, sum_i + dy1);
-            t -= tex2D(maskSumTex, sum_j + dx1, sum_i + dy2);
-            t -= tex2D(maskSumTex, sum_j + dx2, sum_i + dy1);
-            t += tex2D(maskSumTex, sum_j + dx2, sum_i + dy2);
+        float t = 0;
+        t += tex2D(maskSumTex, sum_j + dx1, sum_i + dy1);
+        t -= tex2D(maskSumTex, sum_j + dx1, sum_i + dy2);
+        t -= tex2D(maskSumTex, sum_j + dx2, sum_i + dy1);
+        t += tex2D(maskSumTex, sum_j + dx2, sum_i + dy2);
 
-            d += t * c_DM[4] / ((dx2 - dx1) * (dy2 - dy1));
+        d += t * c_DM[4] / ((dx2 - dx1) * (dy2 - dy1));
 
-            return (d >= 0.5f);
-        }
-    };
+        return (d >= 0.5f);
+    }
+};
 
-    template <typename Mask>
-    __global__ void icvFindMaximaInLayer(const PtrStepf det, const PtrStepf trace, int4* maxPosBuffer, unsigned int* maxCounter)
-    {
-        #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+template <typename Mask>
+__global__ void icvFindMaximaInLayer(const PtrStepf det, const PtrStepf trace, int4* maxPosBuffer, unsigned int* maxCounter)
+{
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
 
-        extern __shared__ float N9[];
+    extern __shared__ float N9[];
 
-        // The hidx variables are the indices to the hessian buffer.
-        const int gridDim_y = gridDim.y / c_nOctaveLayers;
-        const int blockIdx_y = blockIdx.y % gridDim_y;
-        const int blockIdx_z = blockIdx.y / gridDim_y;
+    // The hidx variables are the indices to the hessian buffer.
+    const int gridDim_y = gridDim.y / c_nOctaveLayers;
+    const int blockIdx_y = blockIdx.y % gridDim_y;
+    const int blockIdx_z = blockIdx.y / gridDim_y;
 
-        const int layer = blockIdx_z + 1;
+    const int layer = blockIdx_z + 1;
 
-        const int size = calcSize(c_octave, layer);
+    const int size = calcSize(c_octave, layer);
 
-        // Ignore pixels without a 3x3x3 neighbourhood in the layer above
-        const int margin = ((calcSize(c_octave, layer + 1) >> 1) >> c_octave) + 1;
+    // Ignore pixels without a 3x3x3 neighbourhood in the layer above
+    const int margin = ((calcSize(c_octave, layer + 1) >> 1) >> c_octave) + 1;
 
-        const int j = threadIdx.x + blockIdx.x * (blockDim.x - 2) + margin - 1;
-        const int i = threadIdx.y + blockIdx_y * (blockDim.y - 2) + margin - 1;
+    const int j = threadIdx.x + blockIdx.x * (blockDim.x - 2) + margin - 1;
+    const int i = threadIdx.y + blockIdx_y * (blockDim.y - 2) + margin - 1;
 
-        // Is this thread within the hessian buffer?
-        const int zoff = blockDim.x * blockDim.y;
-        const int localLin = threadIdx.x + threadIdx.y * blockDim.x + zoff;
-        N9[localLin - zoff] = det.ptr(c_layer_rows * (layer - 1) + min(max(i, 0), c_img_rows - 1))[min(max(j, 0), c_img_cols - 1)];
-        N9[localLin       ] = det.ptr(c_layer_rows * (layer    ) + min(max(i, 0), c_img_rows - 1))[min(max(j, 0), c_img_cols - 1)];
-        N9[localLin + zoff] = det.ptr(c_layer_rows * (layer + 1) + min(max(i, 0), c_img_rows - 1))[min(max(j, 0), c_img_cols - 1)];
-        __syncthreads();
+    // Is this thread within the hessian buffer?
+    const int zoff = blockDim.x * blockDim.y;
+    const int localLin = threadIdx.x + threadIdx.y * blockDim.x + zoff;
+    N9[localLin - zoff] = det.ptr(c_layer_rows * (layer - 1) + ::min(::max(i, 0), c_img_rows - 1))[::min(::max(j, 0), c_img_cols - 1)];
+    N9[localLin       ] = det.ptr(c_layer_rows * (layer    ) + ::min(::max(i, 0), c_img_rows - 1))[::min(::max(j, 0), c_img_cols - 1)];
+    N9[localLin + zoff] = det.ptr(c_layer_rows * (layer + 1) + ::min(::max(i, 0), c_img_rows - 1))[::min(::max(j, 0), c_img_cols - 1)];
+    __syncthreads();
+
+    if (i < c_layer_rows - margin && j < c_layer_cols - margin && threadIdx.x > 0 && threadIdx.x < blockDim.x - 1 && threadIdx.y > 0 && threadIdx.y < blockDim.y - 1)
+    {
+        float val0 = N9[localLin];
 
-        if (i < c_layer_rows - margin && j < c_layer_cols - margin && threadIdx.x > 0 && threadIdx.x < blockDim.x - 1 && threadIdx.y > 0 && threadIdx.y < blockDim.y - 1)
+        if (val0 > c_hessianThreshold)
         {
-            float val0 = N9[localLin];
+            // Coordinates for the start of the wavelet in the sum image. There
+            // is some integer division involved, so don't try to simplify this
+            // (cancel out sampleStep) without checking the result is the same
+            const int sum_i = (i - ((size >> 1) >> c_octave)) << c_octave;
+            const int sum_j = (j - ((size >> 1) >> c_octave)) << c_octave;
 
-            if (val0 > c_hessianThreshold)
+            if (Mask::check(sum_i, sum_j, size))
             {
-                // Coordinates for the start of the wavelet in the sum image. There
-                // is some integer division involved, so don't try to simplify this
-                // (cancel out sampleStep) without checking the result is the same
-                const int sum_i = (i - ((size >> 1) >> c_octave)) << c_octave;
-                const int sum_j = (j - ((size >> 1) >> c_octave)) << c_octave;
-
-                if (Mask::check(sum_i, sum_j, size))
+                // Check to see if we have a max (in its 26 neighbours)
+                const bool condmax = val0 > N9[localLin - 1 - blockDim.x - zoff]
+                &&                   val0 > N9[localLin     - blockDim.x - zoff]
+                &&                   val0 > N9[localLin + 1 - blockDim.x - zoff]
+                &&                   val0 > N9[localLin - 1              - zoff]
+                &&                   val0 > N9[localLin                  - zoff]
+                &&                   val0 > N9[localLin + 1              - zoff]
+                &&                   val0 > N9[localLin - 1 + blockDim.x - zoff]
+                &&                   val0 > N9[localLin     + blockDim.x - zoff]
+                &&                   val0 > N9[localLin + 1 + blockDim.x - zoff]
+
+                &&                   val0 > N9[localLin - 1 - blockDim.x]
+                &&                   val0 > N9[localLin     - blockDim.x]
+                &&                   val0 > N9[localLin + 1 - blockDim.x]
+                &&                   val0 > N9[localLin - 1             ]
+                &&                   val0 > N9[localLin + 1             ]
+                &&                   val0 > N9[localLin - 1 + blockDim.x]
+                &&                   val0 > N9[localLin     + blockDim.x]
+                &&                   val0 > N9[localLin + 1 + blockDim.x]
+
+                &&                   val0 > N9[localLin - 1 - blockDim.x + zoff]
+                &&                   val0 > N9[localLin     - blockDim.x + zoff]
+                &&                   val0 > N9[localLin + 1 - blockDim.x + zoff]
+                &&                   val0 > N9[localLin - 1              + zoff]
+                &&                   val0 > N9[localLin                  + zoff]
+                &&                   val0 > N9[localLin + 1              + zoff]
+                &&                   val0 > N9[localLin - 1 + blockDim.x + zoff]
+                &&                   val0 > N9[localLin     + blockDim.x + zoff]
+                &&                   val0 > N9[localLin + 1 + blockDim.x + zoff]
+                ;
+
+                if(condmax)
                 {
-                    // Check to see if we have a max (in its 26 neighbours)
-                    const bool condmax = val0 > N9[localLin - 1 - blockDim.x - zoff]
-                    &&                   val0 > N9[localLin     - blockDim.x - zoff]
-                    &&                   val0 > N9[localLin + 1 - blockDim.x - zoff]
-                    &&                   val0 > N9[localLin - 1              - zoff]
-                    &&                   val0 > N9[localLin                  - zoff]
-                    &&                   val0 > N9[localLin + 1              - zoff]
-                    &&                   val0 > N9[localLin - 1 + blockDim.x - zoff]
-                    &&                   val0 > N9[localLin     + blockDim.x - zoff]
-                    &&                   val0 > N9[localLin + 1 + blockDim.x - zoff]
-
-                    &&                   val0 > N9[localLin - 1 - blockDim.x]
-                    &&                   val0 > N9[localLin     - blockDim.x]
-                    &&                   val0 > N9[localLin + 1 - blockDim.x]
-                    &&                   val0 > N9[localLin - 1             ]
-                    &&                   val0 > N9[localLin + 1             ]
-                    &&                   val0 > N9[localLin - 1 + blockDim.x]
-                    &&                   val0 > N9[localLin     + blockDim.x]
-                    &&                   val0 > N9[localLin + 1 + blockDim.x]
-
-                    &&                   val0 > N9[localLin - 1 - blockDim.x + zoff]
-                    &&                   val0 > N9[localLin     - blockDim.x + zoff]
-                    &&                   val0 > N9[localLin + 1 - blockDim.x + zoff]
-                    &&                   val0 > N9[localLin - 1              + zoff]
-                    &&                   val0 > N9[localLin                  + zoff]
-                    &&                   val0 > N9[localLin + 1              + zoff]
-                    &&                   val0 > N9[localLin - 1 + blockDim.x + zoff]
-                    &&                   val0 > N9[localLin     + blockDim.x + zoff]
-                    &&                   val0 > N9[localLin + 1 + blockDim.x + zoff]
-                    ;
-
-                    if(condmax)
-                    {
-                        unsigned int ind = atomicInc(maxCounter,(unsigned int) -1);
+                    unsigned int ind = atomicInc(maxCounter,(unsigned int) -1);
 
-                        if (ind < c_max_candidates)
-                        {
-                            const int laplacian = (int) copysignf(1.0f, trace.ptr(layer * c_layer_rows + i)[j]);
+                    if (ind < c_max_candidates)
+                    {
+                        const int laplacian = (int) copysignf(1.0f, trace.ptr(layer * c_layer_rows + i)[j]);
 
-                            maxPosBuffer[ind] = make_int4(j, i, layer, laplacian);
-                        }
+                        maxPosBuffer[ind] = make_int4(j, i, layer, laplacian);
                     }
                 }
             }
         }
-
-        #endif
     }
 
-    void icvFindMaximaInLayer_gpu(const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
-        int img_rows, int img_cols, int octave, bool use_mask, int nOctaveLayers)
-    {
-        const int layer_rows = img_rows >> octave;
-        const int layer_cols = img_cols >> octave;
+    #endif
+}
 
-        const int min_margin = ((calcSize(octave, 2) >> 1) >> octave) + 1;
+void icvFindMaximaInLayer_gpu(const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
+    int img_rows, int img_cols, int octave, bool use_mask, int nOctaveLayers)
+{
+    const int layer_rows = img_rows >> octave;
+    const int layer_cols = img_cols >> octave;
 
-        dim3 threads(16, 16);
+    const int min_margin = ((calcSize(octave, 2) >> 1) >> octave) + 1;
 
-        dim3 grid;
-        grid.x = divUp(layer_cols - 2 * min_margin, threads.x - 2);
-        grid.y = divUp(layer_rows - 2 * min_margin, threads.y - 2) * nOctaveLayers;
+    dim3 threads(16, 16);
 
-        const size_t smem_size = threads.x * threads.y * 3 * sizeof(float);
+    dim3 grid;
+    grid.x = divUp(layer_cols - 2 * min_margin, threads.x - 2);
+    grid.y = divUp(layer_rows - 2 * min_margin, threads.y - 2) * nOctaveLayers;
 
-        if (use_mask)
-            icvFindMaximaInLayer<WithMask><<<grid, threads, smem_size>>>(det, trace, maxPosBuffer, maxCounter);
-        else
-            icvFindMaximaInLayer<WithOutMask><<<grid, threads, smem_size>>>(det, trace, maxPosBuffer, maxCounter);
+    const size_t smem_size = threads.x * threads.y * 3 * sizeof(float);
 
-        cudaSafeCall( cudaGetLastError() );
+    if (use_mask)
+        icvFindMaximaInLayer<WithMask><<<grid, threads, smem_size>>>(det, trace, maxPosBuffer, maxCounter);
+    else
+        icvFindMaximaInLayer<WithOutMask><<<grid, threads, smem_size>>>(det, trace, maxPosBuffer, maxCounter);
 
-        cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    cudaSafeCall( cudaGetLastError() );
 
-    ////////////////////////////////////////////////////////////////////////
-    // INTERPOLATION
-    
-    __global__ void icvInterpolateKeypoint(const PtrStepf det, const int4* maxPosBuffer,
-        float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian,
-        unsigned int* featureCounter)
-    {
-        #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+    cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+////////////////////////////////////////////////////////////////////////
+// INTERPOLATION
 
-        const int4 maxPos = maxPosBuffer[blockIdx.x];
+__global__ void icvInterpolateKeypoint(const PtrStepf det, const int4* maxPosBuffer,
+    float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian,
+    unsigned int* featureCounter)
+{
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
 
-        const int j = maxPos.x - 1 + threadIdx.x;
-        const int i = maxPos.y - 1 + threadIdx.y;
-        const int layer = maxPos.z - 1 + threadIdx.z;
+    const int4 maxPos = maxPosBuffer[blockIdx.x];
 
-        __shared__ float N9[3][3][3];
+    const int j = maxPos.x - 1 + threadIdx.x;
+    const int i = maxPos.y - 1 + threadIdx.y;
+    const int layer = maxPos.z - 1 + threadIdx.z;
 
-        N9[threadIdx.z][threadIdx.y][threadIdx.x] = det.ptr(c_layer_rows * layer + i)[j];
-        __syncthreads();
+    __shared__ float N9[3][3][3];
 
-        if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0)
+    N9[threadIdx.z][threadIdx.y][threadIdx.x] = det.ptr(c_layer_rows * layer + i)[j];
+    __syncthreads();
+
+    if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0)
+    {
+        __shared__ float dD[3];
+
+        //dx
+        dD[0] = -0.5f * (N9[1][1][2] - N9[1][1][0]);
+        //dy
+        dD[1] = -0.5f * (N9[1][2][1] - N9[1][0][1]);
+        //ds
+        dD[2] = -0.5f * (N9[2][1][1] - N9[0][1][1]);
+
+        __shared__ float H[3][3];
+
+        //dxx
+        H[0][0] = N9[1][1][0] - 2.0f * N9[1][1][1] + N9[1][1][2];
+        //dxy
+        H[0][1]= 0.25f * (N9[1][2][2] - N9[1][2][0] - N9[1][0][2] + N9[1][0][0]);
+        //dxs
+        H[0][2]= 0.25f * (N9[2][1][2] - N9[2][1][0] - N9[0][1][2] + N9[0][1][0]);
+        //dyx = dxy
+        H[1][0] = H[0][1];
+        //dyy
+        H[1][1] = N9[1][0][1] - 2.0f * N9[1][1][1] + N9[1][2][1];
+        //dys
+        H[1][2]= 0.25f * (N9[2][2][1] - N9[2][0][1] - N9[0][2][1] + N9[0][0][1]);
+        //dsx = dxs
+        H[2][0] = H[0][2];
+        //dsy = dys
+        H[2][1] = H[1][2];
+        //dss
+        H[2][2] = N9[0][1][1] - 2.0f * N9[1][1][1] + N9[2][1][1];
+
+        __shared__ float x[3];
+
+        if (solve3x3(H, dD, x))
         {
-            __shared__ float dD[3];
-
-            //dx
-            dD[0] = -0.5f * (N9[1][1][2] - N9[1][1][0]);
-            //dy
-            dD[1] = -0.5f * (N9[1][2][1] - N9[1][0][1]);
-            //ds
-            dD[2] = -0.5f * (N9[2][1][1] - N9[0][1][1]);
-
-            __shared__ float H[3][3];
-
-            //dxx
-            H[0][0] = N9[1][1][0] - 2.0f * N9[1][1][1] + N9[1][1][2];
-            //dxy
-            H[0][1]= 0.25f * (N9[1][2][2] - N9[1][2][0] - N9[1][0][2] + N9[1][0][0]);
-            //dxs
-            H[0][2]= 0.25f * (N9[2][1][2] - N9[2][1][0] - N9[0][1][2] + N9[0][1][0]);
-            //dyx = dxy
-            H[1][0] = H[0][1];
-            //dyy
-            H[1][1] = N9[1][0][1] - 2.0f * N9[1][1][1] + N9[1][2][1];
-            //dys
-            H[1][2]= 0.25f * (N9[2][2][1] - N9[2][0][1] - N9[0][2][1] + N9[0][0][1]);
-            //dsx = dxs
-            H[2][0] = H[0][2];
-            //dsy = dys
-            H[2][1] = H[1][2];
-            //dss
-            H[2][2] = N9[0][1][1] - 2.0f * N9[1][1][1] + N9[2][1][1];
-
-            __shared__ float x[3];
-
-            if (solve3x3(H, dD, x))
+            if (::fabs(x[0]) <= 1.f && ::fabs(x[1]) <= 1.f && ::fabs(x[2]) <= 1.f)
             {
-                if (fabs(x[0]) <= 1.f && fabs(x[1]) <= 1.f && fabs(x[2]) <= 1.f)
-                {
-                    // if the step is within the interpolation region, perform it
-                    
-                    const int size = calcSize(c_octave, maxPos.z);
-
-                    const int sum_i = (maxPos.y - ((size >> 1) >> c_octave)) << c_octave;
-                    const int sum_j = (maxPos.x - ((size >> 1) >> c_octave)) << c_octave;
-                    
-                    const float center_i = sum_i + (float)(size - 1) / 2;
-                    const float center_j = sum_j + (float)(size - 1) / 2;
-
-                    const float px = center_j + x[0] * (1 << c_octave);
-                    const float py = center_i + x[1] * (1 << c_octave);
-
-                    const int ds = size - calcSize(c_octave, maxPos.z - 1);
-                    const float psize = roundf(size + x[2] * ds);
-
-                    /* The sampling intervals and wavelet sized for selecting an orientation
-                     and building the keypoint descriptor are defined relative to 's' */
-                    const float s = psize * 1.2f / 9.0f;
-
-                    /* To find the dominant orientation, the gradients in x and y are
-                     sampled in a circle of radius 6s using wavelets of size 4s.
-                     We ensure the gradient wavelet size is even to ensure the
-                     wavelet pattern is balanced and symmetric around its center */
-                    const int grad_wav_size = 2 * __float2int_rn(2.0f * s);
-
-                    // check when grad_wav_size is too big
-                    if ((c_img_rows + 1) >= grad_wav_size && (c_img_cols + 1) >= grad_wav_size)
-                    {
-                        // Get a new feature index.
-                        unsigned int ind = atomicInc(featureCounter, (unsigned int)-1);
-
-                        if (ind < c_max_features)
-                        {
-                            featureX[ind] = px;
-                            featureY[ind] = py;
-                            featureLaplacian[ind] = maxPos.w;
-                            featureSize[ind] = psize;
-                            featureHessian[ind] = N9[1][1][1];
-                        }
-                    } // grad_wav_size check
-                } // If the subpixel interpolation worked
-            }
-        } // If this is thread 0.
+                // if the step is within the interpolation region, perform it
+                
+                const int size = calcSize(c_octave, maxPos.z);
 
-        #endif
-    }
+                const int sum_i = (maxPos.y - ((size >> 1) >> c_octave)) << c_octave;
+                const int sum_j = (maxPos.x - ((size >> 1) >> c_octave)) << c_octave;
+                
+                const float center_i = sum_i + (float)(size - 1) / 2;
+                const float center_j = sum_j + (float)(size - 1) / 2;
 
-    void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter, 
-        float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian, 
-        unsigned int* featureCounter)
-    {
-        dim3 threads;
-        threads.x = 3;
-        threads.y = 3;
-        threads.z = 3;
+                const float px = center_j + x[0] * (1 << c_octave);
+                const float py = center_i + x[1] * (1 << c_octave);
 
-        dim3 grid;
-        grid.x = maxCounter;
+                const int ds = size - calcSize(c_octave, maxPos.z - 1);
+                const float psize = roundf(size + x[2] * ds);
 
-        icvInterpolateKeypoint<<<grid, threads>>>(det, maxPosBuffer, featureX, featureY, featureLaplacian, featureSize, featureHessian, featureCounter);
-        cudaSafeCall( cudaGetLastError() );
+                /* The sampling intervals and wavelet sized for selecting an orientation
+                 and building the keypoint descriptor are defined relative to 's' */
+                const float s = psize * 1.2f / 9.0f;
 
-        cudaSafeCall( cudaDeviceSynchronize() );
-    }
+                /* To find the dominant orientation, the gradients in x and y are
+                 sampled in a circle of radius 6s using wavelets of size 4s.
+                 We ensure the gradient wavelet size is even to ensure the
+                 wavelet pattern is balanced and symmetric around its center */
+                const int grad_wav_size = 2 * __float2int_rn(2.0f * s);
 
-    ////////////////////////////////////////////////////////////////////////
-    // Orientation
+                // check when grad_wav_size is too big
+                if ((c_img_rows + 1) >= grad_wav_size && (c_img_cols + 1) >= grad_wav_size)
+                {
+                    // Get a new feature index.
+                    unsigned int ind = atomicInc(featureCounter, (unsigned int)-1);
 
-    #define ORI_SEARCH_INC 5
-    #define ORI_WIN        60
-    #define ORI_SAMPLES    113
+                    if (ind < c_max_features)
+                    {
+                        featureX[ind] = px;
+                        featureY[ind] = py;
+                        featureLaplacian[ind] = maxPos.w;
+                        featureSize[ind] = psize;
+                        featureHessian[ind] = N9[1][1][1];
+                    }
+                } // grad_wav_size check
+            } // If the subpixel interpolation worked
+        }
+    } // If this is thread 0.
 
-    __constant__ float c_aptX[ORI_SAMPLES] = {-6, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6};
-    __constant__ float c_aptY[ORI_SAMPLES] = {0, -3, -2, -1, 0, 1, 2, 3, -4, -3, -2, -1, 0, 1, 2, 3, 4, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, 0};
-    __constant__ float c_aptW[ORI_SAMPLES] = {0.001455130288377404f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.001455130288377404f, 0.0035081731621176f, 0.00720730796456337f, 0.01261763460934162f, 0.0188232995569706f, 0.02392910048365593f, 0.02592208795249462f, 0.02392910048365593f, 0.0188232995569706f, 0.01261763460934162f, 0.00720730796456337f, 0.0035081731621176f, 0.001455130288377404f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.001455130288377404f};
-    
-    __constant__ float c_NX[2][5] = {{0, 0, 2, 4, -1}, {2, 0, 4, 4, 1}};
-    __constant__ float c_NY[2][5] = {{0, 0, 4, 2, 1}, {0, 2, 4, 4, -1}};
+    #endif
+}
 
-    __global__ void icvCalcOrientation(const float* featureX, const float* featureY, const float* featureSize, float* featureDir)
-    {        
-        #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter, 
+    float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian, 
+    unsigned int* featureCounter)
+{
+    dim3 threads;
+    threads.x = 3;
+    threads.y = 3;
+    threads.z = 3;
 
-        __shared__ float s_X[128];
-        __shared__ float s_Y[128];
-        __shared__ float s_angle[128];
+    dim3 grid;
+    grid.x = maxCounter;
 
-        __shared__ float s_sum[32 * 4];
+    icvInterpolateKeypoint<<<grid, threads>>>(det, maxPosBuffer, featureX, featureY, featureLaplacian, featureSize, featureHessian, featureCounter);
+    cudaSafeCall( cudaGetLastError() );
 
-        /* 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;
+    cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-        /* To find the dominant orientation, the gradients in x and y are
-         sampled in a circle of radius 6s using wavelets of size 4s.
-         We ensure the gradient wavelet size is even to ensure the
-         wavelet pattern is balanced and symmetric around its center */
-        const int grad_wav_size = 2 * __float2int_rn(2.0f * s);
+////////////////////////////////////////////////////////////////////////
+// Orientation
 
-        // check when grad_wav_size is too big
-        if ((c_img_rows + 1) >= grad_wav_size && (c_img_cols + 1) >= grad_wav_size)
-        {
-            // Calc X, Y, angle and store it to shared memory
-            const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+#define ORI_SEARCH_INC 5
+#define ORI_WIN        60
+#define ORI_SAMPLES    113
 
-            float X = 0.0f, Y = 0.0f, angle = 0.0f;
+__constant__ float c_aptX[ORI_SAMPLES] = {-6, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6};
+__constant__ float c_aptY[ORI_SAMPLES] = {0, -3, -2, -1, 0, 1, 2, 3, -4, -3, -2, -1, 0, 1, 2, 3, 4, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, 0};
+__constant__ float c_aptW[ORI_SAMPLES] = {0.001455130288377404f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.001455130288377404f, 0.0035081731621176f, 0.00720730796456337f, 0.01261763460934162f, 0.0188232995569706f, 0.02392910048365593f, 0.02592208795249462f, 0.02392910048365593f, 0.0188232995569706f, 0.01261763460934162f, 0.00720730796456337f, 0.0035081731621176f, 0.001455130288377404f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.001455130288377404f};
 
-            if (tid < ORI_SAMPLES)
-            {
-                const float margin = (float)(grad_wav_size - 1) / 2.0f;
-                const int x = __float2int_rn(featureX[blockIdx.x] + c_aptX[tid] * s - margin);
-                const int y = __float2int_rn(featureY[blockIdx.x] + c_aptY[tid] * s - margin);
+__constant__ float c_NX[2][5] = {{0, 0, 2, 4, -1}, {2, 0, 4, 4, 1}};
+__constant__ float c_NY[2][5] = {{0, 0, 4, 2, 1}, {0, 2, 4, 4, -1}};
 
-                if ((unsigned)y < (unsigned)((c_img_rows + 1) - grad_wav_size) && (unsigned)x < (unsigned)((c_img_cols + 1) - grad_wav_size))
-                {
-                    X = c_aptW[tid] * icvCalcHaarPatternSum<2>(c_NX, 4, grad_wav_size, y, x);
-                    Y = c_aptW[tid] * icvCalcHaarPatternSum<2>(c_NY, 4, grad_wav_size, y, x);
-                
-                    angle = atan2f(Y, X);
-                    if (angle < 0)
-                        angle += 2.0f * CV_PI;
-                    angle *= 180.0f / CV_PI;
-                }
-            }
-            s_X[tid] = X;
-            s_Y[tid] = Y;
-            s_angle[tid] = angle;
-            __syncthreads();
+__global__ void icvCalcOrientation(const float* featureX, const float* featureY, const float* featureSize, float* featureDir)
+{        
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
 
-            float bestx = 0, besty = 0, best_mod = 0;
+    __shared__ float s_X[128];
+    __shared__ float s_Y[128];
+    __shared__ float s_angle[128];
 
-            #pragma unroll
-            for (int i = 0; i < 18; ++i)
-            {
-                const int dir = (i * 4 + threadIdx.y) * ORI_SEARCH_INC;
+    __shared__ float s_sum[32 * 4];
 
-                float sumx = 0.0f, sumy = 0.0f;
-                int d = abs(__float2int_rn(s_angle[threadIdx.x]) - dir);
-                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
-                {
-                    sumx = s_X[threadIdx.x];
-                    sumy = s_Y[threadIdx.x];
-                }
-                d = abs(__float2int_rn(s_angle[threadIdx.x + 32]) - dir);
-                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
-                {
-                    sumx += s_X[threadIdx.x + 32];
-                    sumy += s_Y[threadIdx.x + 32];
-                }
-                d = abs(__float2int_rn(s_angle[threadIdx.x + 64]) - dir);
-                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
-                {
-                    sumx += s_X[threadIdx.x + 64];
-                    sumy += s_Y[threadIdx.x + 64];
-                }
-                d = abs(__float2int_rn(s_angle[threadIdx.x + 96]) - dir);
-                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
-                {
-                    sumx += s_X[threadIdx.x + 96];
-                    sumy += s_Y[threadIdx.x + 96];
-                }
+    /* 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;
 
-                float* s_sum_row = s_sum + threadIdx.y * 32;
+    /* To find the dominant orientation, the gradients in x and y are
+     sampled in a circle of radius 6s using wavelets of size 4s.
+     We ensure the gradient wavelet size is even to ensure the
+     wavelet pattern is balanced and symmetric around its center */
+    const int grad_wav_size = 2 * __float2int_rn(2.0f * s);
 
-                reduce<32>(s_sum_row, sumx, threadIdx.x, plus<volatile float>());
-                reduce<32>(s_sum_row, sumy, threadIdx.x, plus<volatile float>());
+    // check when grad_wav_size is too big
+    if ((c_img_rows + 1) >= grad_wav_size && (c_img_cols + 1) >= grad_wav_size)
+    {
+        // Calc X, Y, angle and store it to shared memory
+        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
 
-                const float temp_mod = sumx * sumx + sumy * sumy;
-                if (temp_mod > best_mod)
-                {
-                    best_mod = temp_mod;
-                    bestx = sumx;
-                    besty = sumy;
-                }
-            }
+        float X = 0.0f, Y = 0.0f, angle = 0.0f;
+
+        if (tid < ORI_SAMPLES)
+        {
+            const float margin = (float)(grad_wav_size - 1) / 2.0f;
+            const int x = __float2int_rn(featureX[blockIdx.x] + c_aptX[tid] * s - margin);
+            const int y = __float2int_rn(featureY[blockIdx.x] + c_aptY[tid] * s - margin);
 
-            if (threadIdx.x == 0)
+            if ((unsigned)y < (unsigned)((c_img_rows + 1) - grad_wav_size) && (unsigned)x < (unsigned)((c_img_cols + 1) - grad_wav_size))
             {
-                s_X[threadIdx.y] = bestx;
-                s_Y[threadIdx.y] = besty;
-                s_angle[threadIdx.y] = best_mod;
+                X = c_aptW[tid] * icvCalcHaarPatternSum<2>(c_NX, 4, grad_wav_size, y, x);
+                Y = c_aptW[tid] * icvCalcHaarPatternSum<2>(c_NY, 4, grad_wav_size, y, x);
+            
+                angle = atan2f(Y, X);
+                if (angle < 0)
+                    angle += 2.0f * CV_PI;
+                angle *= 180.0f / CV_PI;
             }
-            __syncthreads();
+        }
+        s_X[tid] = X;
+        s_Y[tid] = Y;
+        s_angle[tid] = angle;
+        __syncthreads();
 
-            if (threadIdx.x < 2 && threadIdx.y == 0)
-            {
-                volatile float* v_x = s_X;
-                volatile float* v_y = s_Y;
-                volatile float* v_mod = s_angle;
+        float bestx = 0, besty = 0, best_mod = 0;
 
-                bestx = v_x[threadIdx.x];
-                besty = v_y[threadIdx.x];
-                best_mod = v_mod[threadIdx.x];
+        #pragma unroll
+        for (int i = 0; i < 18; ++i)
+        {
+            const int dir = (i * 4 + threadIdx.y) * ORI_SEARCH_INC;
 
-                float temp_mod = v_mod[threadIdx.x + 2];
-                if (temp_mod > best_mod)
-                {
-                    v_x[threadIdx.x] = bestx = v_x[threadIdx.x + 2];
-                    v_y[threadIdx.x] = besty = v_y[threadIdx.x + 2];
-                    v_mod[threadIdx.x] = best_mod = temp_mod;
-                }
-                temp_mod = v_mod[threadIdx.x + 1];
-                if (temp_mod > best_mod)
-                {
-                    v_x[threadIdx.x] = bestx = v_x[threadIdx.x + 1];
-                    v_y[threadIdx.x] = besty = v_y[threadIdx.x + 1];
-                }
+            float sumx = 0.0f, sumy = 0.0f;
+            int d = ::abs(__float2int_rn(s_angle[threadIdx.x]) - dir);
+            if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+            {
+                sumx = s_X[threadIdx.x];
+                sumy = s_Y[threadIdx.x];
             }
-
-            if (threadIdx.x == 0 && threadIdx.y == 0 && best_mod != 0)
+            d = ::abs(__float2int_rn(s_angle[threadIdx.x + 32]) - dir);
+            if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+            {
+                sumx += s_X[threadIdx.x + 32];
+                sumy += s_Y[threadIdx.x + 32];
+            }
+            d = ::abs(__float2int_rn(s_angle[threadIdx.x + 64]) - dir);
+            if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+            {
+                sumx += s_X[threadIdx.x + 64];
+                sumy += s_Y[threadIdx.x + 64];
+            }
+            d = ::abs(__float2int_rn(s_angle[threadIdx.x + 96]) - dir);
+            if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
             {
-                float kp_dir = atan2f(besty, bestx);
-                if (kp_dir < 0)
-                    kp_dir += 2.0f * CV_PI;
-                kp_dir *= 180.0f / CV_PI;
+                sumx += s_X[threadIdx.x + 96];
+                sumy += s_Y[threadIdx.x + 96];
+            }
+
+            float* s_sum_row = s_sum + threadIdx.y * 32;
 
-                featureDir[blockIdx.x] = kp_dir;
+            device::reduce<32>(s_sum_row, sumx, threadIdx.x, plus<volatile float>());
+            device::reduce<32>(s_sum_row, sumy, threadIdx.x, plus<volatile float>());
+
+            const float temp_mod = sumx * sumx + sumy * sumy;
+            if (temp_mod > best_mod)
+            {
+                best_mod = temp_mod;
+                bestx = sumx;
+                besty = sumy;
             }
         }
 
-        #endif
-    }
+        if (threadIdx.x == 0)
+        {
+            s_X[threadIdx.y] = bestx;
+            s_Y[threadIdx.y] = besty;
+            s_angle[threadIdx.y] = best_mod;
+        }
+        __syncthreads();
 
-    #undef ORI_SEARCH_INC
-    #undef ORI_WIN
-    #undef ORI_SAMPLES
+        if (threadIdx.x < 2 && threadIdx.y == 0)
+        {
+            volatile float* v_x = s_X;
+            volatile float* v_y = s_Y;
+            volatile float* v_mod = s_angle;
 
-    void icvCalcOrientation_gpu(const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures) 
-    {
-        dim3 threads;
-        threads.x = 32;
-        threads.y = 4;
+            bestx = v_x[threadIdx.x];
+            besty = v_y[threadIdx.x];
+            best_mod = v_mod[threadIdx.x];
 
-        dim3 grid;
-        grid.x = nFeatures;
+            float temp_mod = v_mod[threadIdx.x + 2];
+            if (temp_mod > best_mod)
+            {
+                v_x[threadIdx.x] = bestx = v_x[threadIdx.x + 2];
+                v_y[threadIdx.x] = besty = v_y[threadIdx.x + 2];
+                v_mod[threadIdx.x] = best_mod = temp_mod;
+            }
+            temp_mod = v_mod[threadIdx.x + 1];
+            if (temp_mod > best_mod)
+            {
+                v_x[threadIdx.x] = bestx = v_x[threadIdx.x + 1];
+                v_y[threadIdx.x] = besty = v_y[threadIdx.x + 1];
+            }
+        }
 
-        icvCalcOrientation<<<grid, threads>>>(featureX, featureY, featureSize, featureDir);
-        cudaSafeCall( cudaGetLastError() );
+        if (threadIdx.x == 0 && threadIdx.y == 0 && best_mod != 0)
+        {
+            float kp_dir = atan2f(besty, bestx);
+            if (kp_dir < 0)
+                kp_dir += 2.0f * CV_PI;
+            kp_dir *= 180.0f / CV_PI;
 
-        cudaSafeCall( cudaDeviceSynchronize() );
+            featureDir[blockIdx.x] = kp_dir;
+        }
     }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Descriptors
+    #endif
+}
 
-    #define PATCH_SZ 20
+#undef ORI_SEARCH_INC
+#undef ORI_WIN
+#undef ORI_SAMPLES
 
-    texture<unsigned char, 2, cudaReadModeElementType> imgTex(0, cudaFilterModePoint, cudaAddressModeClamp);
+void icvCalcOrientation_gpu(const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures) 
+{
+    dim3 threads;
+    threads.x = 32;
+    threads.y = 4;
 
-    __constant__ float c_DW[PATCH_SZ * PATCH_SZ] = 
-    {
-        3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f, 
-        8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f, 
-        1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f, 
-        3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f, 
-        5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f, 
-        9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f, 
-        0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f, 
-        0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f, 
-        0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f, 
-        0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f, 
-        0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f, 
-        0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f, 
-        0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f, 
-        0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f, 
-        9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f, 
-        5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f, 
-        3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f, 
-        1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f, 
-        8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f, 
-        3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f
-    };
-
-    struct WinReader
-    {
-        typedef uchar elem_type;
+    dim3 grid;
+    grid.x = nFeatures;
 
-        __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_)
-        {
-        }
+    icvCalcOrientation<<<grid, threads>>>(featureX, featureY, featureSize, featureDir);
+    cudaSafeCall( cudaGetLastError() );
 
-        __device__ __forceinline__ uchar operator ()(int i, int j) const
-        {
-            float pixel_x = centerX + (win_offset + j) * cos_dir + (win_offset + i) * sin_dir;
-            float pixel_y = centerY - (win_offset + j) * sin_dir + (win_offset + i) * cos_dir;
+    cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-            return tex2D(imgTex, pixel_x, pixel_y);
-        }
+////////////////////////////////////////////////////////////////////////
+// Descriptors
+
+#define PATCH_SZ 20
 
-        float centerX; 
-        float centerY;
-        float win_offset; 
-        float cos_dir; 
-        float sin_dir;
-    };
+__constant__ float c_DW[PATCH_SZ * PATCH_SZ] = 
+{
+    3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f, 
+    8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f, 
+    1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f, 
+    3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f, 
+    5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f, 
+    9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f, 
+    0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f, 
+    0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f, 
+    0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f, 
+    0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f, 
+    0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f, 
+    0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f, 
+    0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f, 
+    0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f, 
+    9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f, 
+    5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f, 
+    3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f, 
+    1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f, 
+    8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f, 
+    3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f
+};
+
+struct WinReader
+{
+    typedef uchar elem_type;
 
-    __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__ __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_)
     {
-        __shared__ float s_PATCH[6][6];
+    }
 
-        const float centerX = featureX[blockIdx.x];
-        const float centerY = featureY[blockIdx.x];
-        const float size = featureSize[blockIdx.x];
-        const float descriptor_dir = featureDir[blockIdx.x] * (float)(CV_PI / 180);
+    __device__ __forceinline__ uchar operator ()(int i, int j) const
+    {
+        float pixel_x = centerX + (win_offset + j) * cos_dir + (win_offset + i) * sin_dir;
+        float pixel_y = centerY - (win_offset + j) * sin_dir + (win_offset + i) * cos_dir;
 
-        /* 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;
+        return tex2D(imgTex, pixel_x, pixel_y);
+    }
 
-        /* Extract a window of pixels around the keypoint of size 20s */
-        const int win_size = (int)((PATCH_SZ + 1) * s);
+    float centerX; 
+    float centerY;
+    float win_offset; 
+    float cos_dir; 
+    float sin_dir;
+};
 
-        float sin_dir;
-        float cos_dir;
-        sincosf(descriptor_dir, &sin_dir, &cos_dir);
+__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)
+{
+    __shared__ float s_PATCH[6][6];
 
-        /* Nearest neighbour version (faster) */
-        const float win_offset = -(float)(win_size - 1) / 2; 
+    const float centerX = featureX[blockIdx.x];
+    const float centerY = featureY[blockIdx.x];
+    const float size = featureSize[blockIdx.x];
+    const float descriptor_dir = featureDir[blockIdx.x] * (float)(CV_PI / 180);
 
-        // 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;
+    /* 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;
 
-        const float icoo = ((float)yIndex / (PATCH_SZ + 1)) * win_size;
-        const float jcoo = ((float)xIndex / (PATCH_SZ + 1)) * win_size;
+    /* Extract a window of pixels around the keypoint of size 20s */
+    const int win_size = (int)((PATCH_SZ + 1) * s);
 
-        LinearFilter<WinReader> filter(WinReader(centerX, centerY, win_offset, cos_dir, sin_dir));
+    float sin_dir;
+    float cos_dir;
+    sincosf(descriptor_dir, &sin_dir, &cos_dir);
 
-        s_PATCH[threadIdx.y][threadIdx.x] = filter(icoo, jcoo);
+    /* Nearest neighbour version (faster) */
+    const float win_offset = -(float)(win_size - 1) / 2; 
 
-        __syncthreads();
+    // 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;
 
-        if (threadIdx.x < 5 && threadIdx.y < 5)
-        {
-            const int tid = threadIdx.y * 5 + threadIdx.x;
+    const float icoo = ((float)yIndex / (PATCH_SZ + 1)) * win_size;
+    const float jcoo = ((float)xIndex / (PATCH_SZ + 1)) * win_size;
 
-            const float dw = c_DW[yIndex * PATCH_SZ + xIndex];
+    LinearFilter<WinReader> filter(WinReader(centerX, centerY, win_offset, cos_dir, sin_dir));
 
-            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_PATCH[threadIdx.y][threadIdx.x] = filter(icoo, jcoo);
 
-            s_dx_bin[tid] = vx;
-            s_dy_bin[tid] = vy;
-        }
-    }
+    __syncthreads();
 
-    __device__ void reduce_sum25(volatile float* sdata1, volatile float* sdata2, volatile float* sdata3, volatile float* sdata4, int tid)
+    if (threadIdx.x < 5 && threadIdx.y < 5)
     {
-        // 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];
-        }
+        const int tid = threadIdx.y * 5 + threadIdx.x;
 
-        // 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];
-        }
-    }
+        const float dw = c_DW[yIndex * PATCH_SZ + xIndex];
 
-	__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];
+        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;
 
-        calc_dx_dy(sdx, sdy, featureX, featureY, featureSize, featureDir);
-        __syncthreads();
+        s_dx_bin[tid] = vx;
+        s_dy_bin[tid] = vy;
+    }
+}
 
-        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+__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];
+    }
 
-        if (tid < 25)
-        {
-            sdxabs[tid] = fabs(sdx[tid]); // |dx| array
-            sdyabs[tid] = fabs(sdy[tid]); // |dy| array
-            __syncthreads();
+    // 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];
+    }
+}
 
-            reduce_sum25(sdx, sdy, sdxabs, sdyabs, tid);
-            __syncthreads();
+__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];
 
-            float* descriptors_block = descriptors.ptr(blockIdx.x) + (blockIdx.y << 2);
+    calc_dx_dy(sdx, sdy, featureX, featureY, featureSize, featureDir);
+    __syncthreads();
 
-            // write dx, dy, |dx|, |dy|
-            if (tid == 0)
-            {
-                descriptors_block[0] = sdx[0];
-                descriptors_block[1] = sdy[0];
-                descriptors_block[2] = sdxabs[0];
-                descriptors_block[3] = sdyabs[0];
-            }
-        }
-    }
+    const int tid = threadIdx.y * blockDim.x + threadIdx.x;
 
-	__global__ void compute_descriptors128(PtrStepf descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
+    if (tid < 25)
     {
-        // 2 floats (dx,dy) for each thread (5x5 sample points in each sub-region)
-        __shared__ float sdx[25];
-        __shared__ float sdy[25];
-
-        // sum (reduce) 5x5 area response
-        __shared__ float sd1[25];
-        __shared__ float sd2[25];
-        __shared__ float sdabs1[25];
-        __shared__ float sdabs2[25];
+        sdxabs[tid] = ::fabs(sdx[tid]); // |dx| array
+        sdyabs[tid] = ::fabs(sdy[tid]); // |dy| array
+        __syncthreads();
 
-        calc_dx_dy(sdx, sdy, featureX, featureY, featureSize, featureDir);
+        reduce_sum25(sdx, sdy, sdxabs, sdyabs, tid);
         __syncthreads();
 
-        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+        float* descriptors_block = descriptors.ptr(blockIdx.x) + (blockIdx.y << 2);
 
-        if (tid < 25)
+        // write dx, dy, |dx|, |dy|
+        if (tid == 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);
+            descriptors_block[0] = sdx[0];
+            descriptors_block[1] = sdy[0];
+            descriptors_block[2] = sdxabs[0];
+            descriptors_block[3] = sdyabs[0];
+        }
+    }
+}
 
-            // 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();
+__global__ void compute_descriptors128(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];
 
-            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();
+    // sum (reduce) 5x5 area response
+    __shared__ float sd1[25];
+    __shared__ float sd2[25];
+    __shared__ float sdabs1[25];
+    __shared__ float sdabs2[25];
 
-            reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
-            __syncthreads();
+    calc_dx_dy(sdx, sdy, featureX, featureY, featureSize, featureDir);
+    __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];
-            }
-        }
-    }
+    const int tid = threadIdx.y * blockDim.x + threadIdx.x;
 
-    template <int BLOCK_DIM_X> __global__ void normalize_descriptors(PtrStepf descriptors)
+    if (tid < 25)
     {
-        // no need for thread ID
-        float* descriptor_base = descriptors.ptr(blockIdx.x);
+        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();
 
-        // 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;
+        reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
         __syncthreads();
 
-        if (BLOCK_DIM_X >= 128)
+        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)
         {
-            if (threadIdx.x < 64)
-                sqDesc[threadIdx.x] += sqDesc[threadIdx.x + 64];
-            __syncthreads();
+            descriptors_block[0] = sd1[0];
+            descriptors_block[1] = sdabs1[0];
+            descriptors_block[2] = sd2[0];
+            descriptors_block[3] = sdabs2[0];
         }
+        __syncthreads();
 
-        // reduction to get total
-        if (threadIdx.x < 32)
+        if (sdx[tid] >= 0)
         {
-            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];
+            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();
 
-        // compute length (square root)
-        __shared__ float len;
-        if (threadIdx.x == 0)
+        reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
+        __syncthreads();
+
+        // write dy (dx >= 0), |dy| (dx >= 0), dy (dx < 0), |dy| (dx < 0)
+        if (tid == 0)
         {
-            len = sqrtf(sqDesc[0]);
+            descriptors_block[4] = sd1[0];
+            descriptors_block[5] = sdabs1[0];
+            descriptors_block[6] = sd2[0];
+            descriptors_block[7] = sdabs2[0];
         }
+    }
+}
+
+template <int BLOCK_DIM_X> __global__ void normalize_descriptors(PtrStepf descriptors)
+{
+    // 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();
+
+    if (BLOCK_DIM_X >= 128)
+    {
+        if (threadIdx.x < 64)
+            sqDesc[threadIdx.x] += sqDesc[threadIdx.x + 64];
         __syncthreads();
+    }
 
-        // normalize and store in output
-        descriptor_base[threadIdx.x] = lookup / len;
+    // 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];
     }
 
-    void compute_descriptors_gpu(const DevMem2Df& descriptors, 
-        const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures)
+    // compute length (square root)
+    __shared__ float len;
+    if (threadIdx.x == 0)
     {
-        // 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);
-            cudaSafeCall( cudaGetLastError() );
+        len = sqrtf(sqDesc[0]);
+    }
+    __syncthreads();
 
-            cudaSafeCall( cudaDeviceSynchronize() );
+    // normalize and store in output
+    descriptor_base[threadIdx.x] = lookup / len;
+}
 
-            normalize_descriptors<64><<<dim3(nFeatures, 1, 1), dim3(64, 1, 1)>>>(descriptors);
-            cudaSafeCall( cudaGetLastError() );
+void compute_descriptors_gpu(const DevMem2Df& 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);
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-        else
-        {
-            compute_descriptors128<<<dim3(nFeatures, 16, 1), dim3(6, 6, 1)>>>(descriptors, featureX, featureY, featureSize, featureDir);            
-            cudaSafeCall( cudaGetLastError() );
+        cudaSafeCall( cudaDeviceSynchronize() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
+        normalize_descriptors<64><<<dim3(nFeatures, 1, 1), dim3(64, 1, 1)>>>(descriptors);
+        cudaSafeCall( cudaGetLastError() );
 
-            normalize_descriptors<128><<<dim3(nFeatures, 1, 1), dim3(128, 1, 1)>>>(descriptors);            
-            cudaSafeCall( cudaGetLastError() );
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+    else
+    {
+        compute_descriptors128<<<dim3(nFeatures, 16, 1), dim3(6, 6, 1)>>>(descriptors, featureX, featureY, featureSize, featureDir);            
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+        normalize_descriptors<128><<<dim3(nFeatures, 1, 1), dim3(128, 1, 1)>>>(descriptors);            
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
     }
-}}}
+}
+
+} // namespace surf
+
+END_OPENCV_DEVICE_NAMESPACE
diff --git a/modules/gpu/src/cudastream.cpp b/modules/gpu/src/cudastream.cpp
index 880794b0db3f9256ddeda76575b101252edfb3ad..fee450785d6e011da8c1dc17f9ab76920a1e00a5 100644
--- a/modules/gpu/src/cudastream.cpp
+++ b/modules/gpu/src/cudastream.cpp
@@ -71,16 +71,20 @@ cv::gpu::Stream::operator bool() const { throw_nogpu(); return false; }
 
 #include "opencv2/gpu/stream_accessor.hpp"
 
-namespace cv { namespace gpu { namespace device {            
-    void copy_to_with_mask(const DevMem2Db& src, DevMem2Db dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream = 0);
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream);
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+void copy_to_with_mask(const DevMem2Db& src, DevMem2Db dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream = 0);
+
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream);
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+
+void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
+
+END_OPENCV_DEVICE_NAMESPACE
 
-    void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
-}}}
+using namespace OPENCV_DEVICE_NAMESPACE;
 
 struct Stream::Impl
 {
@@ -101,14 +105,14 @@ namespace
     void kernelSet(GpuMat& src, const Scalar& s, cudaStream_t stream)
     {
         Scalar_<T> sf = s;
-        device::set_to_gpu(src, sf.val, src.channels(), stream);
+        set_to_gpu(src, sf.val, src.channels(), stream);
     }
 
     template <typename T>
     void kernelSetMask(GpuMat& src, const Scalar& s, const GpuMat& mask, cudaStream_t stream)
     {
         Scalar_<T> sf = s;
-        device::set_to_gpu(src, sf.val, mask, src.channels(), stream);
+        set_to_gpu(src, sf.val, mask, src.channels(), stream);
     }
 }
 
@@ -255,7 +259,7 @@ void cv::gpu::Stream::enqueueConvert(const GpuMat& src, GpuMat& dst, int rtype,
         psrc = &(temp = src);
 
     dst.create( src.size(), rtype );
-    device::convert_gpu(psrc->reshape(1), sdepth, dst.reshape(1), ddepth, alpha, beta, impl->stream);
+    convert_gpu(psrc->reshape(1), sdepth, dst.reshape(1), ddepth, alpha, beta, impl->stream);
 }
 
 cv::gpu::Stream::operator bool() const
diff --git a/modules/gpu/src/element_operations.cpp b/modules/gpu/src/element_operations.cpp
index 51acac7d06cacf40e601641989823821895a4546..0b6957dbc5975a8ccc910eedbb5ea88f265c166b 100644
--- a/modules/gpu/src/element_operations.cpp
+++ b/modules/gpu/src/element_operations.cpp
@@ -123,18 +123,19 @@ namespace
 ////////////////////////////////////////////////////////////////////////
 // add
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T, typename D> 
-    void add_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T, typename D> 
+void add_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+template <typename T, typename D> 
+void add_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
 
-    template <typename T, typename D> 
-    void add_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
 
@@ -173,7 +174,7 @@ void cv::gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Gpu
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
 
@@ -235,18 +236,19 @@ void cv::gpu::add(const GpuMat& src, const Scalar& sc, GpuMat& dst, const GpuMat
 ////////////////////////////////////////////////////////////////////////
 // subtract
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T, typename D> 
-    void subtract_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T, typename D> 
+void subtract_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
 
-    template <typename T, typename D> 
-    void subtract_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
-}}}
+template <typename T, typename D> 
+void subtract_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
 
@@ -285,7 +287,7 @@ void cv::gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cons
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, double val, const DevMem2Db& dst, const PtrStepb& mask, cudaStream_t stream);
 
@@ -347,21 +349,22 @@ void cv::gpu::subtract(const GpuMat& src, const Scalar& sc, GpuMat& dst, const G
 ////////////////////////////////////////////////////////////////////////
 // multiply
 
-namespace cv { namespace gpu { namespace device
-{
-    void multiply_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream);
-    void multiply_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream);
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+void multiply_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream);
+void multiply_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream);
+
+template <typename T, typename D> 
+void multiply_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
 
-    template <typename T, typename D> 
-    void multiply_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+template <typename T, typename D> 
+void multiply_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
 
-    template <typename T, typename D> 
-    void multiply_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
 
@@ -419,7 +422,7 @@ void cv::gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, doub
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
 
@@ -469,24 +472,25 @@ void cv::gpu::multiply(const GpuMat& src, const Scalar& sc, GpuMat& dst, double
 ////////////////////////////////////////////////////////////////////////
 // divide
 
-namespace cv { namespace gpu { namespace device
-{
-    void divide_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream);
-    void divide_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream);
-    
-    template <typename T, typename D> 
-    void divide_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    
-    template <typename T, typename D> 
-    void divide_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
-    
-    template <typename T, typename D> 
-    void divide_gpu(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+void divide_gpu(const DevMem2D_<uchar4>& src1, const DevMem2Df& src2, const DevMem2D_<uchar4>& dst, cudaStream_t stream);
+void divide_gpu(const DevMem2D_<short4>& src1, const DevMem2Df& src2, const DevMem2D_<short4>& dst, cudaStream_t stream);
+
+template <typename T, typename D> 
+void divide_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+template <typename T, typename D> 
+void divide_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
+
+template <typename T, typename D> 
+void divide_gpu(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, double scale, cudaStream_t stream);
 
@@ -544,7 +548,7 @@ void cv::gpu::divide(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, double
 
 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 OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, double val, const DevMem2Db& dst, double scale, cudaStream_t stream);
 
@@ -593,7 +597,7 @@ void cv::gpu::divide(const GpuMat& src, const Scalar& sc, GpuMat& dst, double sc
 
 void cv::gpu::divide(double scale, const GpuMat& src, GpuMat& dst, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(double scalar, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
 
@@ -626,18 +630,19 @@ void cv::gpu::divide(double scale, const GpuMat& src, GpuMat& dst, int dtype, St
 //////////////////////////////////////////////////////////////////////////////
 // absdiff
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T> 
-    void absdiff_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    
-    template <typename T> 
-    void absdiff_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, cudaStream_t stream);
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T>
+void absdiff_gpu(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+template <typename T> 
+void absdiff_gpu(const DevMem2Db& src1, double val, const DevMem2Db& dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
 
@@ -709,7 +714,7 @@ void cv::gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Strea
 
 void cv::gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, double val, const DevMem2Db& dst, cudaStream_t stream);
 
@@ -753,17 +758,18 @@ void cv::gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst, Strea
 //////////////////////////////////////////////////////////////////////////////
 // Comparison of two matrixes
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T> void compare_eq(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template <typename T> void compare_ne(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template <typename T> void compare_lt(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-    template <typename T> void compare_le(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T> void compare_eq(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template <typename T> void compare_ne(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template <typename T> void compare_lt(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+template <typename T> void compare_le(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop, Stream& stream)
 {
-    using namespace cv::gpu::device;
+    using namespace OPENCV_DEVICE_NAMESPACE;
 
     typedef void (*func_t)(const DevMem2Db& src1, const DevMem2Db& src2, const DevMem2Db& dst, cudaStream_t stream);
 
@@ -829,13 +835,14 @@ void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int c
 //////////////////////////////////////////////////////////////////////////////
 // Unary bitwise logical operations
 
-namespace cv { namespace gpu { namespace device
-{
-    void bitwiseNotCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src, PtrStepb dst, cudaStream_t stream);
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T>
-    void bitwiseMaskNotCaller(int rows, int cols, int cn, const PtrStepb src, const PtrStepb mask, PtrStepb dst, cudaStream_t stream);
-}}}
+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);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
@@ -843,20 +850,23 @@ namespace
     {
         dst.create(src.size(), src.type());
 
-        cv::gpu::device::bitwiseNotCaller(src.rows, src.cols, src.elemSize1(), 
-                                              dst.channels(), src, dst, stream);
+        OPENCV_DEVICE_NAMESPACE_ 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;
+        using namespace OPENCV_DEVICE_NAMESPACE;
 
         typedef void (*Caller)(int, int, int, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static Caller callers[] = {device::bitwiseMaskNotCaller<unsigned char>, device::bitwiseMaskNotCaller<unsigned char>, 
-                                   device::bitwiseMaskNotCaller<unsigned short>, device::bitwiseMaskNotCaller<unsigned short>,
-                                   device::bitwiseMaskNotCaller<unsigned int>, device::bitwiseMaskNotCaller<unsigned int>,
-                                   device::bitwiseMaskNotCaller<unsigned int>};
+
+        static Caller callers[] = 
+        {
+            bitwiseMaskNotCaller<unsigned char>, bitwiseMaskNotCaller<unsigned char>, 
+            bitwiseMaskNotCaller<unsigned short>, bitwiseMaskNotCaller<unsigned short>,
+            bitwiseMaskNotCaller<unsigned int>, bitwiseMaskNotCaller<unsigned int>,
+            bitwiseMaskNotCaller<unsigned int>
+        };
 
         CV_Assert(mask.type() == CV_8U && mask.size() == src.size());
         dst.create(src.size(), src.type());
@@ -874,33 +884,33 @@ namespace
 void cv::gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, Stream& stream)
 {
     if (mask.empty())
-        ::bitwiseNotCaller(src, dst, StreamAccessor::getStream(stream));
+        bitwiseNotCaller(src, dst, StreamAccessor::getStream(stream));
     else
-        ::bitwiseNotCaller(src, dst, mask, StreamAccessor::getStream(stream));
+        bitwiseNotCaller(src, dst, mask, StreamAccessor::getStream(stream));
 }
 
 
 //////////////////////////////////////////////////////////////////////////////
 // Binary bitwise logical operations
 
-namespace cv { namespace gpu { namespace device
-{
-    void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    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 bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, const PtrStepb src2, 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 bitwiseMaskOrCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2, const PtrStepb mask, 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 bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, const PtrStepb src2, 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 bitwiseMaskAndCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2, const PtrStepb mask, 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);
-}}}
+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);
 
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
@@ -909,20 +919,22 @@ namespace
         CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
         dst.create(src1.size(), src1.type());
 
-        cv::gpu::device::bitwiseOrCaller(dst.rows, dst.cols, dst.elemSize1(), 
-                                             dst.channels(), src1, src2, dst, stream);
+        OPENCV_DEVICE_NAMESPACE_ bitwiseOrCaller(dst.rows, dst.cols, dst.elemSize1(), dst.channels(), src1, src2, dst, stream);
     }
 
-
     void bitwiseOrCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, cudaStream_t stream)
     {
-        using namespace cv::gpu;
+        using namespace OPENCV_DEVICE_NAMESPACE;
 
         typedef void (*Caller)(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static Caller callers[] = {device::bitwiseMaskOrCaller<unsigned char>, device::bitwiseMaskOrCaller<unsigned char>, 
-                                   device::bitwiseMaskOrCaller<unsigned short>, device::bitwiseMaskOrCaller<unsigned short>,
-                                   device::bitwiseMaskOrCaller<unsigned int>, device::bitwiseMaskOrCaller<unsigned int>,
-                                   device::bitwiseMaskOrCaller<unsigned int>};
+
+        static Caller callers[] = 
+        {
+            bitwiseMaskOrCaller<unsigned char>, bitwiseMaskOrCaller<unsigned char>, 
+            bitwiseMaskOrCaller<unsigned short>, bitwiseMaskOrCaller<unsigned short>,
+            bitwiseMaskOrCaller<unsigned int>, bitwiseMaskOrCaller<unsigned int>,
+            bitwiseMaskOrCaller<unsigned int>
+        };
 
         CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
         dst.create(src1.size(), src1.type());
@@ -940,20 +952,23 @@ namespace
         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);
+        OPENCV_DEVICE_NAMESPACE_ 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;
+        using namespace OPENCV_DEVICE_NAMESPACE;
 
         typedef void (*Caller)(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static Caller callers[] = {device::bitwiseMaskAndCaller<unsigned char>, device::bitwiseMaskAndCaller<unsigned char>, 
-                                   device::bitwiseMaskAndCaller<unsigned short>, device::bitwiseMaskAndCaller<unsigned short>,
-                                   device::bitwiseMaskAndCaller<unsigned int>, device::bitwiseMaskAndCaller<unsigned int>,
-                                   device::bitwiseMaskAndCaller<unsigned int>};
+
+        static Caller callers[] = 
+        {
+            bitwiseMaskAndCaller<unsigned char>, bitwiseMaskAndCaller<unsigned char>, 
+            bitwiseMaskAndCaller<unsigned short>, bitwiseMaskAndCaller<unsigned short>,
+            bitwiseMaskAndCaller<unsigned int>, bitwiseMaskAndCaller<unsigned int>,
+            bitwiseMaskAndCaller<unsigned int>
+        };
 
         CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
         dst.create(src1.size(), src1.type());
@@ -971,20 +986,23 @@ namespace
         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);
+        OPENCV_DEVICE_NAMESPACE_ 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;
+        using namespace OPENCV_DEVICE_NAMESPACE;
 
         typedef void (*Caller)(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static Caller callers[] = {device::bitwiseMaskXorCaller<unsigned char>, device::bitwiseMaskXorCaller<unsigned char>, 
-                                   device::bitwiseMaskXorCaller<unsigned short>, device::bitwiseMaskXorCaller<unsigned short>,
-                                   device::bitwiseMaskXorCaller<unsigned int>, device::bitwiseMaskXorCaller<unsigned int>,
-                                   device::bitwiseMaskXorCaller<unsigned int>};
+
+        static Caller callers[] = 
+        {
+            bitwiseMaskXorCaller<unsigned char>, bitwiseMaskXorCaller<unsigned char>, 
+            bitwiseMaskXorCaller<unsigned short>, bitwiseMaskXorCaller<unsigned short>,
+            bitwiseMaskXorCaller<unsigned int>, bitwiseMaskXorCaller<unsigned int>,
+            bitwiseMaskXorCaller<unsigned int>
+        };
 
         CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
         dst.create(src1.size(), src1.type());
@@ -1001,47 +1019,48 @@ namespace
 void cv::gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& stream)
 {
     if (mask.empty())
-        ::bitwiseOrCaller(src1, src2, dst, StreamAccessor::getStream(stream));
+        bitwiseOrCaller(src1, src2, dst, StreamAccessor::getStream(stream));
     else
-        ::bitwiseOrCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
+        bitwiseOrCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
 }
 
 
 void cv::gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& stream)
 {
     if (mask.empty())
-        ::bitwiseAndCaller(src1, src2, dst, StreamAccessor::getStream(stream));
+        bitwiseAndCaller(src1, src2, dst, StreamAccessor::getStream(stream));
     else
-        ::bitwiseAndCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
+        bitwiseAndCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
 }
 
 
 void cv::gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& stream)
 {
     if (mask.empty())
-        ::bitwiseXorCaller(src1, src2, dst, StreamAccessor::getStream(stream));
+        bitwiseXorCaller(src1, src2, dst, StreamAccessor::getStream(stream));
     else
-        ::bitwiseXorCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
+        bitwiseXorCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
 }
 
 
 //////////////////////////////////////////////////////////////////////////////
 // Minimum and maximum operations
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T>
-    void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T>
-    void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+template <typename T>
+void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
 
-    template <typename T>
-    void min_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+template <typename T>
+void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
 
-    template <typename T>
-    void max_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream);
-}}}
+template <typename T>
+void min_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+
+template <typename T>
+void max_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
@@ -1050,14 +1069,14 @@ namespace
     {
         CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
         dst.create(src1.size(), src1.type());
-        device::min_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
+        OPENCV_DEVICE_NAMESPACE_ min_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
     }
 
     template <typename T>
     void min_caller(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream)
     {
         dst.create(src1.size(), src1.type());
-        device::min_gpu<T>(src1.reshape(1), saturate_cast<T>(src2), dst.reshape(1), stream);
+        OPENCV_DEVICE_NAMESPACE_ min_gpu<T>(src1.reshape(1), saturate_cast<T>(src2), dst.reshape(1), stream);
     }
     
     template <typename T>
@@ -1065,14 +1084,14 @@ namespace
     {
         CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
         dst.create(src1.size(), src1.type());
-        device::max_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
+        OPENCV_DEVICE_NAMESPACE_ max_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
     }
 
     template <typename T>
     void max_caller(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream)
     {
         dst.create(src1.size(), src1.type());
-        device::max_gpu<T>(src1.reshape(1), saturate_cast<T>(src2), dst.reshape(1), stream);
+        OPENCV_DEVICE_NAMESPACE_ max_gpu<T>(src1.reshape(1), saturate_cast<T>(src2), dst.reshape(1), stream);
     }
 }
 
@@ -1136,18 +1155,18 @@ void cv::gpu::max(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream)
 ////////////////////////////////////////////////////////////////////////
 // threshold
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T>
-    void threshold_gpu(const DevMem2Db& src, const DevMem2Db& dst, T thresh, T maxVal, int type,
-        cudaStream_t stream);
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T>
+void threshold_gpu(const DevMem2Db& src, const DevMem2Db& dst, T thresh, T maxVal, int type, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
     template <typename T> void threshold_caller(const GpuMat& src, GpuMat& dst, double thresh, double maxVal, int type, cudaStream_t stream)
     {
-        device::threshold_gpu<T>(src, dst, saturate_cast<T>(thresh), saturate_cast<T>(maxVal), type, stream);
+        OPENCV_DEVICE_NAMESPACE_ threshold_gpu<T>(src, dst, saturate_cast<T>(thresh), saturate_cast<T>(maxVal), type, stream);
     }
 }
 
@@ -1204,24 +1223,27 @@ double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double
 ////////////////////////////////////////////////////////////////////////
 // pow
 
-namespace cv { namespace gpu { namespace device
-{
-    template<typename T>
-    void pow_caller(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template<typename T>
+void pow_caller(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream)
-{    
-    CV_Assert( src.depth() != CV_64F );
+{
+    using namespace OPENCV_DEVICE_NAMESPACE;
+
+    CV_Assert(src.depth() != CV_64F);
     dst.create(src.size(), src.type());
 
     typedef void (*caller_t)(const DevMem2Db& src, float power, DevMem2Db dst, cudaStream_t stream);
 
     static const caller_t callers[] = 
     {
-        device::pow_caller<unsigned char>,  device::pow_caller<signed char>, 
-        device::pow_caller<unsigned short>, device::pow_caller<short>, 
-        device::pow_caller<int>, device::pow_caller<float>
+        pow_caller<unsigned char>,  pow_caller<signed char>, 
+        pow_caller<unsigned short>, pow_caller<short>, 
+        pow_caller<int>, pow_caller<float>
     };
 
     callers[src.depth()](src.reshape(1), (float)power, dst.reshape(1), StreamAccessor::getStream(stream));    
@@ -1230,14 +1252,17 @@ void cv::gpu::pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream)
 ////////////////////////////////////////////////////////////////////////
 // addWeighted
 
-namespace cv { namespace gpu { namespace device
-{
-    template <typename T1, typename T2, typename D>
-    void addWeighted_gpu(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
-}}}
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T1, typename T2, typename D>
+void addWeighted_gpu(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2, double beta, double gamma, GpuMat& dst, int dtype, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE;
+
     CV_Assert(src1.size() == src2.size());
     CV_Assert(src1.type() == src2.type() || (dtype >= 0 && src1.channels() == src2.channels()));
 
@@ -1256,8 +1281,6 @@ void cv::gpu::addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2,
 
     typedef void (*caller_t)(const DevMem2Db& src1, double alpha, const DevMem2Db& src2, double beta, double gamma, const DevMem2Db& dst, cudaStream_t stream);
 
-    using namespace cv::gpu::device;
-
     static const caller_t callers[7][7][7] =
     {
         {
diff --git a/modules/gpu/src/filtering.cpp b/modules/gpu/src/filtering.cpp
index b5e750903a8c8364b0f9eb67ba60194508dd2cea..f959e31cd9d261d45674f94234ab9ab65fba35a0 100644
--- a/modules/gpu/src/filtering.cpp
+++ b/modules/gpu/src/filtering.cpp
@@ -735,14 +735,21 @@ void cv::gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& ke
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Separable Linear Filter
 
-namespace cv { namespace gpu { namespace filters
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace row_filter
 {
     template <typename T, typename D>
     void linearRowFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+}
 
+namespace column_filter
+{
     template <typename T, typename D>
     void linearColumnFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
@@ -796,6 +803,8 @@ namespace
 
 Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor, int borderType)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ 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))
@@ -837,25 +846,25 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
     switch (srcType)
     {
     case CV_8UC1:
-        func = filters::linearRowFilter_gpu<uchar, float>;
+        func = linearRowFilter_gpu<uchar, float>;
         break;
     case CV_8UC4:
-        func = filters::linearRowFilter_gpu<uchar4, float4>;
+        func = linearRowFilter_gpu<uchar4, float4>;
         break;
     /*case CV_16SC1:
-        func = filters::linearRowFilter_gpu<short, float>;
+        func = linearRowFilter_gpu<short, float>;
         break;*/
     /*case CV_16SC2:
-        func = filters::linearRowFilter_gpu<short2, float2>;
+        func = linearRowFilter_gpu<short2, float2>;
         break;*/
     case CV_16SC3:
-        func = filters::linearRowFilter_gpu<short3, float3>;
+        func = linearRowFilter_gpu<short3, float3>;
         break;
     case CV_32SC1:
-        func = filters::linearRowFilter_gpu<int, float>;
+        func = linearRowFilter_gpu<int, float>;
         break;
     case CV_32FC1:
-        func = filters::linearRowFilter_gpu<float, float>;
+        func = linearRowFilter_gpu<float, float>;
         break;
     }
 
@@ -909,6 +918,8 @@ namespace
 
 Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor, int borderType)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ 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))
@@ -950,25 +961,25 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
     switch (dstType)
     {
     case CV_8UC1:
-        func = filters::linearColumnFilter_gpu<float, uchar>;
+        func = linearColumnFilter_gpu<float, uchar>;
         break;
     case CV_8UC4:
-        func = filters::linearColumnFilter_gpu<float4, uchar4>;
+        func = linearColumnFilter_gpu<float4, uchar4>;
         break;
     /*case CV_16SC1:
-        func = filters::linearColumnFilter_gpu<float, short>;
+        func = linearColumnFilter_gpu<float, short>;
         break;*/
     /*case CV_16SC2:
-        func = filters::linearColumnFilter_gpu<float2, short2>;
+        func = linearColumnFilter_gpu<float2, short2>;
         break;*/
     case CV_16SC3:
-        func = filters::linearColumnFilter_gpu<float3, short3>;
+        func = linearColumnFilter_gpu<float3, short3>;
         break;
     case CV_32SC1:
-        func = filters::linearColumnFilter_gpu<float, int>;
+        func = linearColumnFilter_gpu<float, int>;
         break;
     case CV_32FC1:
-        func = filters::linearColumnFilter_gpu<float, float>;
+        func = linearColumnFilter_gpu<float, float>;
         break;
     }
 
diff --git a/modules/gpu/src/gpumat.cpp b/modules/gpu/src/gpumat.cpp
deleted file mode 100644
index b1818a56c14b58a39e58f81574a85c4f1a590a4e..0000000000000000000000000000000000000000
--- a/modules/gpu/src/gpumat.cpp
+++ /dev/null
@@ -1,863 +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*/
-
-#include "precomp.hpp"
-
-using namespace cv;
-using namespace cv::gpu;
-using namespace std;
-
-cv::gpu::GpuMat::GpuMat(const GpuMat& m) : 
-    flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend)
-{
-    if (refcount)
-        CV_XADD(refcount, 1);
-}
-
-cv::gpu::GpuMat::GpuMat(int rows_, int cols_, int type_, void* data_, size_t step_) : 
-    flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(rows_), cols(cols_), 
-    step(step_), data((uchar*)data_), refcount(0),
-    datastart((uchar*)data_), dataend((uchar*)data_)
-{
-    size_t minstep = cols * elemSize();
-
-    if (step == Mat::AUTO_STEP)
-    {
-        step = minstep;
-        flags |= Mat::CONTINUOUS_FLAG;
-    }
-    else
-    {
-        if (rows == 1) 
-            step = minstep;
-
-        CV_DbgAssert(step >= minstep);
-
-        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
-    }
-    dataend += step * (rows - 1) + minstep;
-}
-
-cv::gpu::GpuMat::GpuMat(Size size_, int type_, void* data_, size_t step_) : 
-    flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(size_.height), cols(size_.width),
-    step(step_), data((uchar*)data_), refcount(0),
-    datastart((uchar*)data_), dataend((uchar*)data_)
-{
-    size_t minstep = cols * elemSize();
-
-    if (step == Mat::AUTO_STEP)
-    {
-        step = minstep;
-        flags |= Mat::CONTINUOUS_FLAG;
-    }
-    else
-    {
-        if (rows == 1) 
-            step = minstep;
-
-        CV_DbgAssert(step >= minstep);
-
-        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
-    }
-    dataend += step * (rows - 1) + minstep;
-}
-
-cv::gpu::GpuMat::GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange)
-{
-    flags = m.flags;
-    step = m.step; refcount = m.refcount;
-    data = m.data; datastart = m.datastart; dataend = m.dataend;
-
-    if (rowRange == Range::all())
-        rows = m.rows;
-    else
-    {
-        CV_Assert(0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows);
-
-        rows = rowRange.size();
-        data += step*rowRange.start;
-    }
-
-    if (colRange == Range::all())
-        cols = m.cols;
-    else
-    {
-        CV_Assert(0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols);
-
-        cols = colRange.size();
-        data += colRange.start*elemSize();
-        flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
-    }
-
-    if (rows == 1)
-        flags |= Mat::CONTINUOUS_FLAG;
-
-    if (refcount)
-        CV_XADD(refcount, 1);
-
-    if (rows <= 0 || cols <= 0)
-        rows = cols = 0;
-}
-
-cv::gpu::GpuMat::GpuMat(const GpuMat& m, const Rect& roi) : 
-    flags(m.flags), rows(roi.height), cols(roi.width),
-    step(m.step), data(m.data + roi.y*step), refcount(m.refcount),
-    datastart(m.datastart), dataend(m.dataend)
-{
-    flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
-    data += roi.x * elemSize();
-
-    CV_Assert(0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols && 0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows);
-
-    if (refcount)
-        CV_XADD(refcount, 1);
-
-    if (rows <= 0 || cols <= 0)
-        rows = cols = 0;
-}
-
-cv::gpu::GpuMat::GpuMat(const Mat& m) : 
-    flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) 
-{ 
-    upload(m); 
-}
-
-GpuMat& cv::gpu::GpuMat::operator = (const GpuMat& m)
-{
-    if (this != &m)
-    {
-        GpuMat temp(m);
-        swap(temp);
-    }
-
-    return *this;
-}
-
-void cv::gpu::GpuMat::swap(GpuMat& b)
-{
-    std::swap(flags, b.flags);
-    std::swap(rows, b.rows); 
-    std::swap(cols, b.cols);
-    std::swap(step, b.step); 
-    std::swap(data, b.data);
-    std::swap(datastart, b.datastart);
-    std::swap(dataend, b.dataend);
-    std::swap(refcount, b.refcount);
-}
-
-void cv::gpu::GpuMat::locateROI(Size& wholeSize, Point& ofs) const
-{
-    size_t esz = elemSize();
-    ptrdiff_t delta1 = data - datastart;
-    ptrdiff_t delta2 = dataend - datastart;
-
-    CV_DbgAssert(step > 0);
-
-    if (delta1 == 0)
-        ofs.x = ofs.y = 0;
-    else
-    {
-        ofs.y = static_cast<int>(delta1 / step);
-        ofs.x = static_cast<int>((delta1 - step * ofs.y) / esz);
-
-        CV_DbgAssert(data == datastart + ofs.y * step + ofs.x * esz);
-    }
-
-    size_t minstep = (ofs.x + cols) * esz;
-
-    wholeSize.height = std::max(static_cast<int>((delta2 - minstep) / step + 1), ofs.y + rows);
-    wholeSize.width = std::max(static_cast<int>((delta2 - step * (wholeSize.height - 1)) / esz), ofs.x + cols);
-}
-
-GpuMat& cv::gpu::GpuMat::adjustROI(int dtop, int dbottom, int dleft, int dright)
-{
-    Size wholeSize; 
-    Point ofs;
-    locateROI(wholeSize, ofs);
-
-    size_t esz = elemSize();
-
-    int row1 = std::max(ofs.y - dtop, 0); 
-    int row2 = std::min(ofs.y + rows + dbottom, wholeSize.height);
-
-    int col1 = std::max(ofs.x - dleft, 0);
-    int col2 = std::min(ofs.x + cols + dright, wholeSize.width);
-
-    data += (row1 - ofs.y) * step + (col1 - ofs.x) * esz;
-    rows = row2 - row1; 
-    cols = col2 - col1;
-
-    if (esz * cols == step || rows == 1)
-        flags |= Mat::CONTINUOUS_FLAG;
-    else
-        flags &= ~Mat::CONTINUOUS_FLAG;
-
-    return *this;
-}
-
-GpuMat cv::gpu::GpuMat::reshape(int new_cn, int new_rows) const
-{
-    GpuMat hdr = *this;
-
-    int cn = channels();
-    if (new_cn == 0)
-        new_cn = cn;
-
-    int total_width = cols * cn;
-
-    if ((new_cn > total_width || total_width % new_cn != 0) && new_rows == 0)
-        new_rows = rows * total_width / new_cn;
-
-    if (new_rows != 0 && new_rows != rows)
-    {
-        int total_size = total_width * rows;
-
-        if (!isContinuous())
-            CV_Error(CV_BadStep, "The matrix is not continuous, thus its number of rows can not be changed");
-
-        if ((unsigned)new_rows > (unsigned)total_size)
-            CV_Error(CV_StsOutOfRange, "Bad new number of rows");
-
-        total_width = total_size / new_rows;
-
-        if (total_width * new_rows != total_size)
-            CV_Error(CV_StsBadArg, "The total number of matrix elements is not divisible by the new number of rows");
-
-        hdr.rows = new_rows;
-        hdr.step = total_width * elemSize1();
-    }
-
-    int new_width = total_width / new_cn;
-
-    if (new_width * new_cn != total_width)
-        CV_Error(CV_BadNumChannels, "The total width is not divisible by the new number of channels");
-
-    hdr.cols = new_width;
-    hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn - 1) << CV_CN_SHIFT);
-
-    return hdr;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-class GpuFuncTable
-{
-public:
-    virtual ~GpuFuncTable() {}
-
-    virtual void copy(const Mat& src, GpuMat& dst) const = 0;
-    virtual void copy(const GpuMat& src, Mat& dst) const = 0;
-    virtual void copy(const GpuMat& src, GpuMat& dst) const = 0;
-
-    virtual void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask) const = 0;
-
-    virtual void convert(const GpuMat& src, GpuMat& dst) const = 0;
-    virtual void convert(const GpuMat& src, GpuMat& dst, double alpha, double beta) const = 0;
-
-    virtual void setTo(GpuMat& m, const Scalar& s, const GpuMat& mask) const = 0;
-
-    virtual void mallocPitch(void** devPtr, size_t* step, size_t width, size_t height) const = 0;
-    virtual void free(void* devPtr) const = 0;
-};
-
-
-#if !defined (HAVE_CUDA)
-
-class EmptyFuncTable : public GpuFuncTable
-{
-public:
-    void copy(const Mat&, GpuMat&) const { throw_nogpu(); }
-    void copy(const GpuMat&, Mat&) const { throw_nogpu(); }
-    void copy(const GpuMat&, GpuMat&) const { throw_nogpu(); }
-
-    void copyWithMask(const GpuMat&, GpuMat&, const GpuMat&) const { throw_nogpu(); }
-
-    void convert(const GpuMat&, GpuMat&) const { throw_nogpu(); }
-    void convert(const GpuMat&, GpuMat&, double, double) const { throw_nogpu(); }
-
-    void setTo(GpuMat&, const Scalar&, const GpuMat&) const { throw_nogpu(); }
-
-    void mallocPitch(void**, size_t*, size_t, size_t) const { throw_nogpu(); }
-    void free(void*) const {}
-};
-
-const GpuFuncTable* gpuFuncTable()
-{
-    static EmptyFuncTable empty;
-    return &empty;
-}
-
-#else
-
-namespace cv { namespace gpu { namespace device
-{
-    void copy_to_with_mask(const DevMem2Db& src, DevMem2Db dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t& stream = 0);
-
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream);
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-
-    void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
-}}}
-
-namespace
-{
-    //////////////////////////////////////////////////////////////////////////
-    // Convert
-
-    template<int n> struct NPPTypeTraits;
-    template<> struct NPPTypeTraits<CV_8U>  { typedef Npp8u npp_type; };
-    template<> struct NPPTypeTraits<CV_16U> { typedef Npp16u npp_type; };
-    template<> struct NPPTypeTraits<CV_16S> { typedef Npp16s npp_type; };
-    template<> struct NPPTypeTraits<CV_32S> { typedef Npp32s npp_type; };
-    template<> struct NPPTypeTraits<CV_32F> { typedef Npp32f npp_type; };
-
-    template<int SDEPTH, int DDEPTH> struct NppConvertFunc
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        typedef NppStatus (*func_ptr)(const src_t* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI);
-    };
-    template<int DDEPTH> struct NppConvertFunc<CV_32F, DDEPTH>
-    {
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        typedef NppStatus (*func_ptr)(const Npp32f* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI, NppRoundMode eRoundMode);
-    };
-
-    template<int SDEPTH, int DDEPTH, typename NppConvertFunc<SDEPTH, DDEPTH>::func_ptr func> struct NppCvt
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        static void cvt(const GpuMat& src, GpuMat& dst)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), dst.ptr<dst_t>(), static_cast<int>(dst.step), sz) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template<int DDEPTH, typename NppConvertFunc<CV_32F, DDEPTH>::func_ptr func> struct NppCvt<CV_32F, DDEPTH, func>
-    {
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        static void cvt(const GpuMat& src, GpuMat& dst)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            nppSafeCall( func(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<dst_t>(), static_cast<int>(dst.step), sz, NPP_RND_NEAR) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    void convertToKernelCaller(const GpuMat& src, GpuMat& dst)
-    {
-        device::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), 1.0, 0.0);
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Set
-    
-    template<int SDEPTH, int SCN> struct NppSetFunc
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
-    };
-    template<int SDEPTH> struct NppSetFunc<SDEPTH, 1>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
-    };
-
-    template<int SDEPTH, int SCN, typename NppSetFunc<SDEPTH, SCN>::func_ptr func> struct NppSet
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-
-            Scalar_<src_t> nppS = s;
-
-            nppSafeCall( func(nppS.val, src.ptr<src_t>(), static_cast<int>(src.step), sz) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template<int SDEPTH, typename NppSetFunc<SDEPTH, 1>::func_ptr func> struct NppSet<SDEPTH, 1, func>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-
-            Scalar_<src_t> nppS = s;
-
-            nppSafeCall( func(nppS[0], src.ptr<src_t>(), static_cast<int>(src.step), sz) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    template <typename T>
-    void kernelSet(GpuMat& src, const Scalar& s)
-    {
-        Scalar_<T> sf = s;
-        device::set_to_gpu(src, sf.val, src.channels(), 0);
-    }
-
-    template<int SDEPTH, int SCN> struct NppSetMaskFunc
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
-    };
-    template<int SDEPTH> struct NppSetMaskFunc<SDEPTH, 1>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
-    };
-
-    template<int SDEPTH, int SCN, typename NppSetMaskFunc<SDEPTH, SCN>::func_ptr func> struct NppSetMask
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s, const GpuMat& mask)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-
-            Scalar_<src_t> nppS = s;
-
-            nppSafeCall( func(nppS.val, src.ptr<src_t>(), static_cast<int>(src.step), sz, mask.ptr<Npp8u>(), static_cast<int>(mask.step)) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template<int SDEPTH, typename NppSetMaskFunc<SDEPTH, 1>::func_ptr func> struct NppSetMask<SDEPTH, 1, func>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s, const GpuMat& mask)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-
-            Scalar_<src_t> nppS = s;
-
-            nppSafeCall( func(nppS[0], src.ptr<src_t>(), static_cast<int>(src.step), sz, mask.ptr<Npp8u>(), static_cast<int>(mask.step)) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    template <typename T>
-    void kernelSetMask(GpuMat& src, const Scalar& s, const GpuMat& mask)
-    {
-        Scalar_<T> sf = s;
-        device::set_to_gpu(src, sf.val, mask, src.channels(), 0);
-    }
-}
-
-class CudaFuncTable : public GpuFuncTable
-{
-public:
-    virtual void copy(const Mat& src, GpuMat& dst) const 
-    { 
-        cudaSafeCall( cudaMemcpy2D(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyHostToDevice) );
-    }
-    virtual void copy(const GpuMat& src, Mat& dst) const
-    { 
-        cudaSafeCall( cudaMemcpy2D(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyDeviceToHost) );
-    }
-    virtual void copy(const GpuMat& src, GpuMat& dst) const
-    { 
-        cudaSafeCall( cudaMemcpy2D(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyDeviceToDevice) );
-    }
-
-    virtual void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask) const 
-    { 
-        device::copy_to_with_mask(src, dst, src.depth(), mask, src.channels());
-    }
-
-    void convert(const GpuMat& src, GpuMat& dst) const 
-    { 
-        typedef void (*caller_t)(const GpuMat& src, GpuMat& dst);
-        static const caller_t callers[7][7][7] =
-        {
-            {                
-                /*  8U ->  8U */ {0, 0, 0, 0},
-                /*  8U ->  8S */ {convertToKernelCaller, convertToKernelCaller, convertToKernelCaller, convertToKernelCaller},
-                /*  8U -> 16U */ {NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C4R>::cvt},
-                /*  8U -> 16S */ {NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C4R>::cvt},
-                /*  8U -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8U -> 32F */ {NppCvt<CV_8U, CV_32F, nppiConvert_8u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8U -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
-            },
-            {
-                /*  8S ->  8U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8S ->  8S */ {0,0,0,0},
-                /*  8S -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8S -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8S -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8S -> 32F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /*  8S -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
-            },
-            {
-                /* 16U ->  8U */ {NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C4R>::cvt},
-                /* 16U ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16U -> 16U */ {0,0,0,0},
-                /* 16U -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16U -> 32S */ {NppCvt<CV_16U, CV_32S, nppiConvert_16u32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16U -> 32F */ {NppCvt<CV_16U, CV_32F, nppiConvert_16u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16U -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
-            },
-            {
-                /* 16S ->  8U */ {NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C4R>::cvt},
-                /* 16S ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16S -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16S -> 16S */ {0,0,0,0},
-                /* 16S -> 32S */ {NppCvt<CV_16S, CV_32S, nppiConvert_16s32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16S -> 32F */ {NppCvt<CV_16S, CV_32F, nppiConvert_16s32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 16S -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
-            },
-            {
-                /* 32S ->  8U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32S ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32S -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32S -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32S -> 32S */ {0,0,0,0},
-                /* 32S -> 32F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32S -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
-            },
-            {
-                /* 32F ->  8U */ {NppCvt<CV_32F, CV_8U, nppiConvert_32f8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32F ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32F -> 16U */ {NppCvt<CV_32F, CV_16U, nppiConvert_32f16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32F -> 16S */ {NppCvt<CV_32F, CV_16S, nppiConvert_32f16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32F -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 32F -> 32F */ {0,0,0,0},
-                /* 32F -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
-            },
-            {
-                /* 64F ->  8U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 64F ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 64F -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 64F -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 64F -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 64F -> 32F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                /* 64F -> 64F */ {0,0,0,0}
-            }
-        };
-
-        caller_t func = callers[src.depth()][dst.depth()][src.channels() - 1];
-        CV_DbgAssert(func != 0);
-
-        func(src, dst);
-    }
-    void convert(const GpuMat& src, GpuMat& dst, double alpha, double beta) const 
-    { 
-        device::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), alpha, beta);
-    }
-
-    void setTo(GpuMat& m, const Scalar& s, const GpuMat& mask) const
-    {
-        NppiSize sz;
-        sz.width  = m.cols;
-        sz.height = m.rows;
-
-        if (mask.empty())
-        {
-            if (s[0] == 0.0 && s[1] == 0.0 && s[2] == 0.0 && s[3] == 0.0)
-            {
-                cudaSafeCall( cudaMemset2D(m.data, m.step, 0, m.cols * m.elemSize(), m.rows) );
-                return;
-            }
-
-            if (m.depth() == CV_8U)
-            {
-                int cn = m.channels();
-
-                if (cn == 1 || (cn == 2 && s[0] == s[1]) || (cn == 3 && s[0] == s[1] && s[0] == s[2]) || (cn == 4 && s[0] == s[1] && s[0] == s[2] && s[0] == s[3]))
-                {
-                    int val = saturate_cast<gpu::uchar>(s[0]);
-                    cudaSafeCall( cudaMemset2D(m.data, m.step, val, m.cols * m.elemSize(), m.rows) );
-                    return;
-                }
-            }
-
-            typedef void (*caller_t)(GpuMat& src, const Scalar& s);
-            static const caller_t callers[7][4] =
-            {
-                {NppSet<CV_8U, 1, nppiSet_8u_C1R>::set,kernelSet<gpu::uchar>,kernelSet<gpu::uchar>,NppSet<CV_8U, 4, nppiSet_8u_C4R>::set},
-                {kernelSet<gpu::schar>,kernelSet<gpu::schar>,kernelSet<gpu::schar>,kernelSet<gpu::schar>},
-                {NppSet<CV_16U, 1, nppiSet_16u_C1R>::set,NppSet<CV_16U, 2, nppiSet_16u_C2R>::set,kernelSet<gpu::ushort>,NppSet<CV_16U, 4, nppiSet_16u_C4R>::set},
-                {NppSet<CV_16S, 1, nppiSet_16s_C1R>::set,NppSet<CV_16S, 2, nppiSet_16s_C2R>::set,kernelSet<short>,NppSet<CV_16S, 4, nppiSet_16s_C4R>::set},
-                {NppSet<CV_32S, 1, nppiSet_32s_C1R>::set,kernelSet<int>,kernelSet<int>,NppSet<CV_32S, 4, nppiSet_32s_C4R>::set},
-                {NppSet<CV_32F, 1, nppiSet_32f_C1R>::set,kernelSet<float>,kernelSet<float>,NppSet<CV_32F, 4, nppiSet_32f_C4R>::set},
-                {kernelSet<double>,kernelSet<double>,kernelSet<double>,kernelSet<double>}
-            };
-
-            callers[m.depth()][m.channels() - 1](m, s);
-        }
-        else
-        {
-            typedef void (*caller_t)(GpuMat& src, const Scalar& s, const GpuMat& mask);
-
-            static const caller_t callers[7][4] =
-            {
-                {NppSetMask<CV_8U, 1, nppiSet_8u_C1MR>::set,kernelSetMask<gpu::uchar>,kernelSetMask<gpu::uchar>,NppSetMask<CV_8U, 4, nppiSet_8u_C4MR>::set},
-                {kernelSetMask<gpu::schar>,kernelSetMask<gpu::schar>,kernelSetMask<gpu::schar>,kernelSetMask<gpu::schar>},
-                {NppSetMask<CV_16U, 1, nppiSet_16u_C1MR>::set,kernelSetMask<gpu::ushort>,kernelSetMask<gpu::ushort>,NppSetMask<CV_16U, 4, nppiSet_16u_C4MR>::set},
-                {NppSetMask<CV_16S, 1, nppiSet_16s_C1MR>::set,kernelSetMask<short>,kernelSetMask<short>,NppSetMask<CV_16S, 4, nppiSet_16s_C4MR>::set},
-                {NppSetMask<CV_32S, 1, nppiSet_32s_C1MR>::set,kernelSetMask<int>,kernelSetMask<int>,NppSetMask<CV_32S, 4, nppiSet_32s_C4MR>::set},
-                {NppSetMask<CV_32F, 1, nppiSet_32f_C1MR>::set,kernelSetMask<float>,kernelSetMask<float>,NppSetMask<CV_32F, 4, nppiSet_32f_C4MR>::set},
-                {kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>}
-            };
-
-            callers[m.depth()][m.channels() - 1](m, s, mask);
-        }
-    }
-
-    void mallocPitch(void** devPtr, size_t* step, size_t width, size_t height) const
-    {
-        cudaSafeCall( cudaMallocPitch(devPtr, step, width, height) );
-    }
-
-    void free(void* devPtr) const
-    {
-        cudaFree(devPtr);
-    }
-};
-
-const GpuFuncTable* gpuFuncTable()
-{
-    static CudaFuncTable cuda;
-    return &cuda;
-}
-
-#endif
-
-void cv::gpu::GpuMat::upload(const Mat& m)
-{
-    CV_DbgAssert(!m.empty());
-
-    create(m.size(), m.type());
-
-    gpuFuncTable()->copy(m, *this);
-}
-
-void cv::gpu::GpuMat::download(cv::Mat& m) const
-{
-    CV_DbgAssert(!empty());
-
-    m.create(size(), type());
-
-    gpuFuncTable()->copy(*this, m);
-}
-
-void cv::gpu::GpuMat::copyTo(GpuMat& m) const
-{
-    CV_DbgAssert(!empty());
-
-    m.create(size(), type());
-
-    gpuFuncTable()->copy(*this, m);
-}
-
-void cv::gpu::GpuMat::copyTo(GpuMat& mat, const GpuMat& mask) const
-{
-    if (mask.empty())
-        copyTo(mat);
-    else
-    {
-        mat.create(size(), type());
-
-        gpuFuncTable()->copyWithMask(*this, mat, mask);
-    }
-}
-
-void cv::gpu::GpuMat::convertTo(GpuMat& dst, int rtype, double alpha, double beta) const
-{
-    bool noScale = fabs(alpha - 1) < numeric_limits<double>::epsilon() && fabs(beta) < numeric_limits<double>::epsilon();
-
-    if (rtype < 0)
-        rtype = type();
-    else
-        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), channels());
-
-    int scn = channels();
-    int sdepth = depth();
-    int ddepth = CV_MAT_DEPTH(rtype);
-    if (sdepth == ddepth && noScale)
-    {
-        copyTo(dst);
-        return;
-    }
-
-    GpuMat temp;
-    const GpuMat* psrc = this;
-    if (sdepth != ddepth && psrc == &dst)
-    {
-        temp = *this;
-        psrc = &temp;
-    }
-
-    dst.create(size(), rtype);
-
-    if (noScale)
-        gpuFuncTable()->convert(*psrc, dst);
-    else
-        gpuFuncTable()->convert(*psrc, dst, alpha, beta);
-}
-
-GpuMat& cv::gpu::GpuMat::setTo(const Scalar& s, const GpuMat& mask)
-{
-    CV_Assert(mask.empty() || mask.type() == CV_8UC1);
-    CV_DbgAssert(!empty());
-
-    gpuFuncTable()->setTo(*this, s, mask);    
-
-    return *this;
-}
-
-void cv::gpu::GpuMat::create(int _rows, int _cols, int _type)
-{
-    _type &= TYPE_MASK;
-
-    if (rows == _rows && cols == _cols && type() == _type && data)
-        return;
-
-    if (data)
-        release();
-
-    CV_DbgAssert(_rows >= 0 && _cols >= 0);
-
-    if (_rows > 0 && _cols > 0)
-    {
-        flags = Mat::MAGIC_VAL + _type;
-        rows = _rows;
-        cols = _cols;
-
-        size_t esz = elemSize();
-
-        void* devPtr;
-        gpuFuncTable()->mallocPitch(&devPtr, &step, esz * cols, rows);
-
-        // Single row must be continuous
-        if (rows == 1)
-            step = esz * cols;
-
-        if (esz * cols == step)
-            flags |= Mat::CONTINUOUS_FLAG;
-
-        int64 _nettosize = static_cast<int64>(step) * rows;
-        size_t nettosize = static_cast<size_t>(_nettosize);
-
-        datastart = data = static_cast<uchar*>(devPtr);
-        dataend = data + nettosize;
-
-        refcount = static_cast<int*>(fastMalloc(sizeof(*refcount)));
-        *refcount = 1;
-    }
-}
-
-void cv::gpu::GpuMat::release()
-{
-    if (refcount && CV_XADD(refcount, -1) == 1)
-    {
-        fastFree(refcount);
-
-        gpuFuncTable()->free(datastart);
-    }
-
-    data = datastart = dataend = 0;
-    step = rows = cols = 0;
-    refcount = 0;
-}
diff --git a/modules/gpu/src/hog.cpp b/modules/gpu/src/hog.cpp
index da00258673b4aaa9a21149f28744ba81109e7ffa..216738123657569de98bc9e98c3a9b3a6d302456 100644
--- a/modules/gpu/src/hog.cpp
+++ b/modules/gpu/src/hog.cpp
@@ -60,40 +60,44 @@ std::vector<float> cv::gpu::HOGDescriptor::getPeopleDetector64x128() { throw_nog
 
 #else
 
-namespace cv { namespace gpu { namespace hog {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-void set_up_constants(int nbins, int block_stride_x, int block_stride_y, 
-                      int nblocks_win_x, int nblocks_win_y);
-
-void compute_hists(int nbins, int block_stride_x, int blovck_stride_y,
-                   int height, int width, const cv::gpu::DevMem2Df& grad, 
-                   const cv::gpu::DevMem2Db& qangle, float sigma, float* block_hists);
-
-void normalize_hists(int nbins, int block_stride_x, int block_stride_y, 
-                     int height, int width, float* block_hists, float threshold);
-
-void classify_hists(int win_height, int win_width, int block_stride_y, 
-                    int block_stride_x, int win_stride_y, int win_stride_x, int height, 
-                    int width, float* block_hists, float* coefs, float free_coef, 
-                    float threshold, unsigned char* labels);
-
-void extract_descrs_by_rows(int win_height, int win_width, int block_stride_y, int block_stride_x, 
-                            int win_stride_y, int win_stride_x, int height, int width, float* block_hists, 
-                            cv::gpu::DevMem2Df descriptors);
-void extract_descrs_by_cols(int win_height, int win_width, int block_stride_y, int block_stride_x, 
-                            int win_stride_y, int win_stride_x, int height, int width, float* block_hists, 
-                            cv::gpu::DevMem2Df descriptors);
-
-void compute_gradients_8UC1(int nbins, int height, int width, const cv::gpu::DevMem2Db& img, 
-                            float angle_scale, cv::gpu::DevMem2Df grad, cv::gpu::DevMem2Db qangle, bool correct_gamma);
-void compute_gradients_8UC4(int nbins, int height, int width, const cv::gpu::DevMem2Db& img, 
-                            float angle_scale, cv::gpu::DevMem2Df grad, cv::gpu::DevMem2Db qangle, bool correct_gamma);
-
-void resize_8UC1(const cv::gpu::DevMem2Db& src, cv::gpu::DevMem2Db dst);
-void resize_8UC4(const cv::gpu::DevMem2Db& src, cv::gpu::DevMem2Db dst);
+namespace hog 
+{
+    void set_up_constants(int nbins, int block_stride_x, int block_stride_y, 
+                          int nblocks_win_x, int nblocks_win_y);
+
+    void compute_hists(int nbins, int block_stride_x, int blovck_stride_y,
+                       int height, int width, const cv::gpu::DevMem2Df& grad, 
+                       const cv::gpu::DevMem2Db& qangle, float sigma, float* block_hists);
+
+    void normalize_hists(int nbins, int block_stride_x, int block_stride_y, 
+                         int height, int width, float* block_hists, float threshold);
+
+    void classify_hists(int win_height, int win_width, int block_stride_y, 
+                        int block_stride_x, int win_stride_y, int win_stride_x, int height, 
+                        int width, float* block_hists, float* coefs, float free_coef, 
+                        float threshold, unsigned char* labels);
+
+    void extract_descrs_by_rows(int win_height, int win_width, int block_stride_y, int block_stride_x, 
+                                int win_stride_y, int win_stride_x, int height, int width, float* block_hists, 
+                                cv::gpu::DevMem2Df descriptors);
+    void extract_descrs_by_cols(int win_height, int win_width, int block_stride_y, int block_stride_x, 
+                                int win_stride_y, int win_stride_x, int height, int width, float* block_hists, 
+                                cv::gpu::DevMem2Df descriptors);
+
+    void compute_gradients_8UC1(int nbins, int height, int width, const cv::gpu::DevMem2Db& img, 
+                                float angle_scale, cv::gpu::DevMem2Df grad, cv::gpu::DevMem2Db qangle, bool correct_gamma);
+    void compute_gradients_8UC4(int nbins, int height, int width, const cv::gpu::DevMem2Db& img, 
+                                float angle_scale, cv::gpu::DevMem2Df grad, cv::gpu::DevMem2Db qangle, bool correct_gamma);
+
+    void resize_8UC1(const cv::gpu::DevMem2Db& src, cv::gpu::DevMem2Db dst);
+    void resize_8UC4(const cv::gpu::DevMem2Db& src, cv::gpu::DevMem2Db dst);
+}
 
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
+using namespace OPENCV_DEVICE_NAMESPACE;
     
 cv::gpu::HOGDescriptor::HOGDescriptor(Size win_size, Size block_size, Size block_stride, Size cell_size, 
 									  int nbins, double win_sigma, double threshold_L2hys, bool gamma_correction, int nlevels)
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index 3b47447a1262703b2e22e2de3705924bf707db08..897328007239f46b9da148d46972c99d2917d7fa 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -107,15 +107,20 @@ void cv::gpu::CannyBuf::release() { throw_nogpu(); }
 ////////////////////////////////////////////////////////////////////////
 // remap
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace remap 
 {
-    template <typename T> void remap_gpu(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, 
-                                         int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-}}}
+    template <typename T> 
+    void remap_gpu(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, 
+                   int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap, int interpolation, int borderMode, const Scalar& borderValue, Stream& stream)
 {
-    using namespace cv::gpu::imgproc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ remap;
 
     typedef void (*caller_t)(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, 
         int borderMode, const float* borderValue, cudaStream_t stream, int cc);
@@ -155,13 +160,19 @@ void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const Gp
 ////////////////////////////////////////////////////////////////////////
 // meanShiftFiltering_GPU
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void meanShiftFiltering_gpu(const DevMem2Db& src, DevMem2Db dst, int sp, int sr, int maxIter, float eps, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr, TermCriteria criteria, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     if( src.empty() )
         CV_Error( CV_StsBadArg, "The input image is empty" );
 
@@ -180,19 +191,25 @@ void cv::gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
         eps = 1.f;
     eps = (float)std::max(criteria.epsilon, 0.0);
 
-    imgproc::meanShiftFiltering_gpu(src, dst, sp, sr, maxIter, eps, StreamAccessor::getStream(stream));
+    meanShiftFiltering_gpu(src, dst, sp, sr, maxIter, eps, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
 // meanShiftProc_GPU
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void meanShiftProc_gpu(const DevMem2Db& src, DevMem2Db dstr, DevMem2Db dstsp, int sp, int sr, int maxIter, float eps, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     if( src.empty() )
         CV_Error( CV_StsBadArg, "The input image is empty" );
 
@@ -212,26 +229,32 @@ void cv::gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int
         eps = 1.f;
     eps = (float)std::max(criteria.epsilon, 0.0);
 
-    imgproc::meanShiftProc_gpu(src, dstr, dstsp, sp, sr, maxIter, eps, StreamAccessor::getStream(stream));
+    meanShiftProc_gpu(src, dstr, dstsp, sp, sr, maxIter, eps, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
 // drawColorDisp
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void drawColorDisp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int ndisp, const cudaStream_t& stream);
     void drawColorDisp_gpu(const DevMem2D_<short>& src, const DevMem2Db& dst, int ndisp, const cudaStream_t& stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
     template <typename T>
     void drawColorDisp_caller(const GpuMat& src, GpuMat& dst, int ndisp, const cudaStream_t& stream)
     {
+        using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
         dst.create(src.size(), CV_8UC4);
 
-        imgproc::drawColorDisp_gpu((DevMem2D_<T>)src, dst, ndisp, stream);
+        drawColorDisp_gpu((DevMem2D_<T>)src, dst, ndisp, stream);
     }
 
     typedef void (*drawColorDisp_caller_t)(const GpuMat& src, GpuMat& dst, int ndisp, const cudaStream_t& stream);
@@ -249,19 +272,26 @@ void cv::gpu::drawColorDisp(const GpuMat& src, GpuMat& dst, int ndisp, Stream& s
 ////////////////////////////////////////////////////////////////////////
 // reprojectImageTo3D
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void reprojectImageTo3D_gpu(const DevMem2Db& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream);
     void reprojectImageTo3D_gpu(const DevMem2D_<short>& disp, const DevMem2Df& xyzw, const float* q, const cudaStream_t& stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
     template <typename T>
     void reprojectImageTo3D_caller(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, const cudaStream_t& stream)
     {
+        using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
         xyzw.create(disp.rows, disp.cols, CV_32FC4);
-        imgproc::reprojectImageTo3D_gpu((DevMem2D_<T>)disp, xyzw, Q.ptr<float>(), stream);
+
+        reprojectImageTo3D_gpu((DevMem2D_<T>)disp, xyzw, Q.ptr<float>(), stream);
     }
 
     typedef void (*reprojectImageTo3D_caller_t)(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, const cudaStream_t& stream);
@@ -279,10 +309,14 @@ void cv::gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q,
 ////////////////////////////////////////////////////////////////////////
 // resize
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace resize 
 {
     template <typename T> void resize_gpu(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, double fy, int interpolation, Stream& s)
 {
@@ -346,7 +380,7 @@ void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, doub
     }
     else
     {
-        using namespace cv::gpu::imgproc;
+        using namespace OPENCV_DEVICE_NAMESPACE_ resize;
 
         typedef void (*caller_t)(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
         static const caller_t callers[6][4] = 
@@ -366,18 +400,24 @@ void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, doub
 ////////////////////////////////////////////////////////////////////////
 // copyMakeBorder
 
-namespace cv { namespace gpu {  namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace copy_make_border 
 {
     template <typename T, int cn> void copyMakeBorder_gpu(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const T* borderValue, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
     template <typename T, int cn> void copyMakeBorder_caller(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderType, const Scalar& value, cudaStream_t stream)
     {
+        using namespace OPENCV_DEVICE_NAMESPACE_ copy_make_border;
+
         Scalar_<T> val(saturate_cast<T>(value[0]), saturate_cast<T>(value[1]), saturate_cast<T>(value[2]), saturate_cast<T>(value[3]));
 
-        imgproc::copyMakeBorder_gpu<T, cn>(src, dst, top, left, borderType, val.val, stream);
+        copyMakeBorder_gpu<T, cn>(src, dst, top, left, borderType, val.val, stream);
     }
 }
 
@@ -626,16 +666,22 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
 //////////////////////////////////////////////////////////////////////////////
 // buildWarpPlaneMaps
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void buildWarpPlaneMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
                             const float k_rinv[9], const float r_kinv[9], const float t[3], float scale,
                             cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, const Mat &T, 
                                  float scale, GpuMat& map_x, GpuMat& map_y, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     CV_Assert(K.size() == Size(3,3) && K.type() == CV_32F);
     CV_Assert(R.size() == Size(3,3) && R.type() == CV_32F);
     CV_Assert((T.size() == Size(3,1) || T.size() == Size(1,3)) && T.type() == CV_32F && T.isContinuous());
@@ -647,23 +693,29 @@ void cv::gpu::buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, cons
 
     map_x.create(dst_roi.size(), CV_32F);
     map_y.create(dst_roi.size(), CV_32F);
-    imgproc::buildWarpPlaneMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), 
-                                T.ptr<float>(), scale, StreamAccessor::getStream(stream));
+    buildWarpPlaneMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), 
+                       T.ptr<float>(), scale, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // buildWarpCylyndricalMaps
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void buildWarpCylindricalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
                                   const float k_rinv[9], const float r_kinv[9], float scale,
                                   cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
                                        GpuMat& map_x, GpuMat& map_y, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     CV_Assert(K.size() == Size(3,3) && K.type() == CV_32F);
     CV_Assert(R.size() == Size(3,3) && R.type() == CV_32F);
 
@@ -674,24 +726,29 @@ void cv::gpu::buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K
 
     map_x.create(dst_roi.size(), CV_32F);
     map_y.create(dst_roi.size(), CV_32F);
-    imgproc::buildWarpCylindricalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(),
-                                      scale, StreamAccessor::getStream(stream));
+    buildWarpCylindricalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
 }
 
 
 //////////////////////////////////////////////////////////////////////////////
 // buildWarpSphericalMaps
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void buildWarpSphericalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
                                 const float k_rinv[9], const float r_kinv[9], float scale,
                                 cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
                                      GpuMat& map_x, GpuMat& map_y, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     CV_Assert(K.size() == Size(3,3) && K.type() == CV_32F);
     CV_Assert(R.size() == Size(3,3) && R.type() == CV_32F);
 
@@ -702,8 +759,7 @@ void cv::gpu::buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K,
 
     map_x.create(dst_roi.size(), CV_32F);
     map_y.create(dst_roi.size(), CV_32F);
-    imgproc::buildWarpSphericalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(),
-                                    scale, StreamAccessor::getStream(stream));
+    buildWarpSphericalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -843,17 +899,24 @@ void cv::gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& s)
 //////////////////////////////////////////////////////////////////////////////
 // columnSum
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc
 {
     void columnSum_32F(const DevMem2Db src, const DevMem2Db dst);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::columnSum(const GpuMat& src, GpuMat& dst)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     CV_Assert(src.type() == CV_32F);
 
     dst.create(src.size(), CV_32F);
-    imgproc::columnSum_32F(src, dst);
+
+    columnSum_32F(src, dst);
 }
 
 void cv::gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& s)
@@ -1140,7 +1203,6 @@ void cv::gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, S
     histRange(src, hist, levels, buf, stream);
 }
 
-
 void cv::gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, Stream& stream)
 {
     CV_Assert(src.type() == CV_8UC1 || src.type() == CV_16UC1 || src.type() == CV_16SC1 || src.type() == CV_32FC1);
@@ -1183,13 +1245,19 @@ 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 histograms
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace hist
 {
     void histogram256_gpu(DevMem2Db src, int* hist, unsigned int* buf, cudaStream_t stream);
 
     const int PARTIAL_HISTOGRAM256_COUNT = 240;
     const int HISTOGRAM256_BIN_COUNT     = 256;
-}}}
+
+    void equalizeHist_gpu(DevMem2Db src, DevMem2Db dst, const int* lut, cudaStream_t stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, Stream& stream)
 {
@@ -1199,7 +1267,7 @@ void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, Stream& stream)
 
 void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream)
 {
-    using namespace cv::gpu::histograms;
+    using namespace OPENCV_DEVICE_NAMESPACE_ hist;
 
     CV_Assert(src.type() == CV_8UC1);
 
@@ -1223,14 +1291,9 @@ void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream&
     equalizeHist(src, dst, hist, buf, stream);
 }
 
-namespace cv { namespace gpu { namespace histograms
-{
-    void equalizeHist_gpu(DevMem2Db src, DevMem2Db dst, const int* lut, cudaStream_t stream);
-}}}
-
 void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& s)
 {
-    using namespace cv::gpu::histograms;
+    using namespace OPENCV_DEVICE_NAMESPACE_ hist;
 
     CV_Assert(src.type() == CV_8UC1);
 
@@ -1264,13 +1327,16 @@ void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat&
 ////////////////////////////////////////////////////////////////////////
 // cornerHarris & minEgenVal
 
-namespace cv { namespace gpu { namespace imgproc {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
+namespace imgproc 
+{
     void extractCovData_caller(const DevMem2Df Dx, const DevMem2Df Dy, PtrStepf dst, cudaStream_t stream);
     void cornerHarris_caller(const int block_size, const float k, const DevMem2Db Dx, const DevMem2Db Dy, DevMem2Db dst, int border_type, cudaStream_t stream);
     void cornerMinEigenVal_caller(const int block_size, const DevMem2Db Dx, const DevMem2Db Dy, DevMem2Db dst, int border_type, cudaStream_t stream);
+}
 
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace 
 {
@@ -1316,7 +1382,6 @@ namespace
 
 } // Anonymous namespace
 
-
 bool cv::gpu::tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType)
 {
     switch (cpuBorderType)
@@ -1356,6 +1421,8 @@ void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& D
 
 void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, double k, int borderType, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     CV_Assert(borderType == cv::BORDER_REFLECT101 ||
               borderType == cv::BORDER_REPLICATE);
 
@@ -1364,7 +1431,7 @@ void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& D
 
     extractCovData(src, Dx, Dy, buf, blockSize, ksize, borderType, stream);
     dst.create(src.size(), CV_32F);
-    imgproc::cornerHarris_caller(blockSize, (float)k, Dx, Dy, dst, gpuBorderType, StreamAccessor::getStream(stream));
+    cornerHarris_caller(blockSize, (float)k, Dx, Dy, dst, gpuBorderType, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType)
@@ -1381,6 +1448,8 @@ void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuM
 
 void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, int borderType, Stream& stream)
 {  
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     CV_Assert(borderType == cv::BORDER_REFLECT101 ||
               borderType == cv::BORDER_REPLICATE);
 
@@ -1389,24 +1458,30 @@ void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuM
 
     extractCovData(src, Dx, Dy, buf, blockSize, ksize, borderType, stream);    
     dst.create(src.size(), CV_32F);
-    imgproc::cornerMinEigenVal_caller(blockSize, Dx, Dy, dst, gpuBorderType, StreamAccessor::getStream(stream));
+    cornerMinEigenVal_caller(blockSize, Dx, Dy, dst, gpuBorderType, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // mulSpectrums
 
-namespace cv { namespace gpu { namespace imgproc 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void mulSpectrums(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c, cudaStream_t stream);
 
     void mulSpectrums_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, DevMem2D_<cufftComplex> c, cudaStream_t stream);
-}}}
+}
 
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB, Stream& stream) 
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     typedef void (*Caller)(const PtrStep<cufftComplex>, const PtrStep<cufftComplex>, DevMem2D_<cufftComplex>, cudaStream_t stream);
-    static Caller callers[] = { imgproc::mulSpectrums, imgproc::mulSpectrums_CONJ };
+
+    static Caller callers[] = { mulSpectrums, mulSpectrums_CONJ };
 
     CV_Assert(a.type() == b.type() && a.type() == CV_32FC2);
     CV_Assert(a.size() == b.size());
@@ -1420,18 +1495,23 @@ void cv::gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flag
 //////////////////////////////////////////////////////////////////////////////
 // mulAndScaleSpectrums
 
-namespace cv { namespace gpu { namespace imgproc 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc 
 {
     void mulAndScaleSpectrums(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c, cudaStream_t stream);
 
     void mulAndScaleSpectrums_CONJ(const PtrStep<cufftComplex> a, const PtrStep<cufftComplex> b, float scale, DevMem2D_<cufftComplex> c, cudaStream_t stream);
-}}}
+}
 
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB, Stream& stream) 
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
     typedef void (*Caller)(const PtrStep<cufftComplex>, const PtrStep<cufftComplex>, float scale, DevMem2D_<cufftComplex>, cudaStream_t stream);
-    static Caller callers[] = { imgproc::mulAndScaleSpectrums, imgproc::mulAndScaleSpectrums_CONJ };
+    static Caller callers[] = { mulAndScaleSpectrums, mulAndScaleSpectrums_CONJ };
 
     CV_Assert(a.type() == b.type() && a.type() == CV_32FC2);
     CV_Assert(a.size() == b.size());
@@ -1593,13 +1673,19 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
     convolve(image, templ, result, ccorr, buf);
 }
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace imgproc
 {
     void convolve_gpu(const DevMem2Df& src, const PtrStepf& dst, int kWidth, int kHeight, float* kernel, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream)
 {
+    using namespace OPENCV_DEVICE_NAMESPACE_ imgproc;
+
 #ifndef HAVE_CUFFT
 
     CV_Assert(image.type() == CV_32F);
@@ -1622,7 +1708,7 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
             templ.copyTo(contKernel);
     }
 
-    imgproc::convolve_gpu(image, result, templ.cols, templ.rows, contKernel.ptr<float>(), StreamAccessor::getStream(stream));
+    convolve_gpu(image, result, templ.cols, templ.rows, contKernel.ptr<float>(), StreamAccessor::getStream(stream));
 
 #else
 
@@ -1650,7 +1736,7 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
                 templ.copyTo(contKernel);
         }
 
-        imgproc::convolve_gpu(image, result, templ.cols, templ.rows, contKernel.ptr<float>(), StreamAccessor::getStream(stream));
+        convolve_gpu(image, result, templ.cols, templ.rows, contKernel.ptr<float>(), StreamAccessor::getStream(stream));
     }
     else
     {
@@ -1725,14 +1811,18 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
 //////////////////////////////////////////////////////////////////////////////
 // pyrDown
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace pyr_down 
 {
     template <typename T, int cn> void pyrDown_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::pyrDown(const GpuMat& src, GpuMat& dst, int borderType, Stream& stream)
 {
-    using namespace cv::gpu::imgproc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ pyr_down;
 
     typedef void (*func_t)(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
@@ -1761,14 +1851,18 @@ void cv::gpu::pyrDown(const GpuMat& src, GpuMat& dst, int borderType, Stream& st
 //////////////////////////////////////////////////////////////////////////////
 // pyrUp
 
-namespace cv { namespace gpu { namespace imgproc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace pyr_up 
 {
     template <typename T, int cn> void pyrUp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::pyrUp(const GpuMat& src, GpuMat& dst, int borderType, Stream& stream)
 {
-    using namespace cv::gpu::imgproc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ pyr_up;
 
     typedef void (*func_t)(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
@@ -1839,8 +1933,10 @@ void cv::gpu::CannyBuf::release()
     trackBuf2.release();
 }
 
-namespace cv { namespace gpu { namespace canny
-{    
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace canny 
+{
     void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols);
 
     void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
@@ -1853,13 +1949,15 @@ namespace cv { namespace gpu { namespace canny
     void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols);
 
     void getEdges_gpu(PtrStepi map, PtrStepb dst, int rows, int cols);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 namespace
 {
     void CannyCaller(CannyBuf& buf, GpuMat& dst, float low_thresh, float high_thresh)
     {
-        using namespace cv::gpu::canny;
+        using namespace OPENCV_DEVICE_NAMESPACE_ canny;
 
         calcMap_gpu(buf.dx, buf.dy, buf.edgeBuf, buf.edgeBuf, dst.rows, dst.cols, low_thresh, high_thresh);
         
@@ -1879,7 +1977,7 @@ void cv::gpu::Canny(const GpuMat& src, GpuMat& dst, double low_thresh, double hi
 
 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::canny;
+    using namespace OPENCV_DEVICE_NAMESPACE_ canny;
 
     CV_Assert(TargetArchs::builtWith(SHARED_ATOMICS) && DeviceInfo().supports(SHARED_ATOMICS));
     CV_Assert(src.type() == CV_8UC1);
@@ -1918,7 +2016,7 @@ void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& dst, double low_
 
 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::canny;
+    using namespace OPENCV_DEVICE_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());
diff --git a/modules/gpu/src/initialization.cpp b/modules/gpu/src/initialization.cpp
index b13c173a3612d10943f3793f0ebdf4dcebf6e71b..e93c899a581bf9a111e1594daa06d46f74e9cdce 100644
--- a/modules/gpu/src/initialization.cpp
+++ b/modules/gpu/src/initialization.cpp
@@ -271,5 +271,380 @@ void cv::gpu::DeviceInfo::queryMemory(size_t& free_memory, size_t& total_memory)
         setDevice(prev_device_id);
 }
 
+////////////////////////////////////////////////////////////////////
+// GpuFuncTable
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+void copy_to_with_mask(const DevMem2Db& src, DevMem2Db dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t& stream = 0);
+
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream);
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+
+void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
+
+END_OPENCV_DEVICE_NAMESPACE
+
+namespace
+{
+    //////////////////////////////////////////////////////////////////////////
+    // Convert
+
+    template<int n> struct NPPTypeTraits;
+    template<> struct NPPTypeTraits<CV_8U>  { typedef Npp8u npp_type; };
+    template<> struct NPPTypeTraits<CV_16U> { typedef Npp16u npp_type; };
+    template<> struct NPPTypeTraits<CV_16S> { typedef Npp16s npp_type; };
+    template<> struct NPPTypeTraits<CV_32S> { typedef Npp32s npp_type; };
+    template<> struct NPPTypeTraits<CV_32F> { typedef Npp32f npp_type; };
+
+    template<int SDEPTH, int DDEPTH> struct NppConvertFunc
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        typedef NppStatus (*func_ptr)(const src_t* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI);
+    };
+    template<int DDEPTH> struct NppConvertFunc<CV_32F, DDEPTH>
+    {
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        typedef NppStatus (*func_ptr)(const Npp32f* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI, NppRoundMode eRoundMode);
+    };
+
+    template<int SDEPTH, int DDEPTH, typename NppConvertFunc<SDEPTH, DDEPTH>::func_ptr func> struct NppCvt
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        static void cvt(const GpuMat& src, GpuMat& dst)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), dst.ptr<dst_t>(), static_cast<int>(dst.step), sz) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+    template<int DDEPTH, typename NppConvertFunc<CV_32F, DDEPTH>::func_ptr func> struct NppCvt<CV_32F, DDEPTH, func>
+    {
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        static void cvt(const GpuMat& src, GpuMat& dst)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            nppSafeCall( func(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<dst_t>(), static_cast<int>(dst.step), sz, NPP_RND_NEAR) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+
+    void convertToKernelCaller(const GpuMat& src, GpuMat& dst)
+    {
+        OPENCV_DEVICE_NAMESPACE_ convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), 1.0, 0.0);
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Set
+    
+    template<int SDEPTH, int SCN> struct NppSetFunc
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
+    };
+    template<int SDEPTH> struct NppSetFunc<SDEPTH, 1>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
+    };
+
+    template<int SDEPTH, int SCN, typename NppSetFunc<SDEPTH, SCN>::func_ptr func> struct NppSet
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, Scalar s)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+
+            Scalar_<src_t> nppS = s;
+
+            nppSafeCall( func(nppS.val, src.ptr<src_t>(), static_cast<int>(src.step), sz) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+    template<int SDEPTH, typename NppSetFunc<SDEPTH, 1>::func_ptr func> struct NppSet<SDEPTH, 1, func>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, Scalar s)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+
+            Scalar_<src_t> nppS = s;
+
+            nppSafeCall( func(nppS[0], src.ptr<src_t>(), static_cast<int>(src.step), sz) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+
+    template <typename T>
+    void kernelSet(GpuMat& src, Scalar s)
+    {
+        Scalar_<T> sf = s;
+        OPENCV_DEVICE_NAMESPACE_ set_to_gpu(src, sf.val, src.channels(), 0);
+    }
+
+    template<int SDEPTH, int SCN> struct NppSetMaskFunc
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
+    };
+    template<int SDEPTH> struct NppSetMaskFunc<SDEPTH, 1>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
+    };
+
+    template<int SDEPTH, int SCN, typename NppSetMaskFunc<SDEPTH, SCN>::func_ptr func> struct NppSetMask
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, Scalar s, const GpuMat& mask)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+
+            Scalar_<src_t> nppS = s;
+
+            nppSafeCall( func(nppS.val, src.ptr<src_t>(), static_cast<int>(src.step), sz, mask.ptr<Npp8u>(), static_cast<int>(mask.step)) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+    template<int SDEPTH, typename NppSetMaskFunc<SDEPTH, 1>::func_ptr func> struct NppSetMask<SDEPTH, 1, func>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, Scalar s, const GpuMat& mask)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+
+            Scalar_<src_t> nppS = s;
+
+            nppSafeCall( func(nppS[0], src.ptr<src_t>(), static_cast<int>(src.step), sz, mask.ptr<Npp8u>(), static_cast<int>(mask.step)) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+
+    template <typename T>
+    void kernelSetMask(GpuMat& src, Scalar s, const GpuMat& mask)
+    {
+        Scalar_<T> sf = s;
+        OPENCV_DEVICE_NAMESPACE_ set_to_gpu(src, sf.val, mask, src.channels(), 0);
+    }
+
+    class CudaFuncTable : public GpuFuncTable
+    {
+    public:
+        void copy(const Mat& src, GpuMat& dst) const 
+        { 
+            cudaSafeCall( cudaMemcpy2D(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyHostToDevice) );
+        }
+        void copy(const GpuMat& src, Mat& dst) const
+        { 
+            cudaSafeCall( cudaMemcpy2D(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyDeviceToHost) );
+        }
+        void copy(const GpuMat& src, GpuMat& dst) const
+        { 
+            cudaSafeCall( cudaMemcpy2D(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyDeviceToDevice) );
+        }
+
+        void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask) const 
+        { 
+            OPENCV_DEVICE_NAMESPACE_ copy_to_with_mask(src, dst, src.depth(), mask, src.channels());
+        }
+
+        void convert(const GpuMat& src, GpuMat& dst) const 
+        { 
+            typedef void (*caller_t)(const GpuMat& src, GpuMat& dst);
+            static const caller_t callers[7][7][7] =
+            {
+                {                
+                    /*  8U ->  8U */ {0, 0, 0, 0},
+                    /*  8U ->  8S */ {convertToKernelCaller, convertToKernelCaller, convertToKernelCaller, convertToKernelCaller},
+                    /*  8U -> 16U */ {NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C4R>::cvt},
+                    /*  8U -> 16S */ {NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C4R>::cvt},
+                    /*  8U -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8U -> 32F */ {NppCvt<CV_8U, CV_32F, nppiConvert_8u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8U -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
+                },
+                {
+                    /*  8S ->  8U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8S ->  8S */ {0,0,0,0},
+                    /*  8S -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8S -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8S -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8S -> 32F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /*  8S -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
+                },
+                {
+                    /* 16U ->  8U */ {NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C4R>::cvt},
+                    /* 16U ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16U -> 16U */ {0,0,0,0},
+                    /* 16U -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16U -> 32S */ {NppCvt<CV_16U, CV_32S, nppiConvert_16u32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16U -> 32F */ {NppCvt<CV_16U, CV_32F, nppiConvert_16u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16U -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
+                },
+                {
+                    /* 16S ->  8U */ {NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C4R>::cvt},
+                    /* 16S ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16S -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16S -> 16S */ {0,0,0,0},
+                    /* 16S -> 32S */ {NppCvt<CV_16S, CV_32S, nppiConvert_16s32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16S -> 32F */ {NppCvt<CV_16S, CV_32F, nppiConvert_16s32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 16S -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
+                },
+                {
+                    /* 32S ->  8U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32S ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32S -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32S -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32S -> 32S */ {0,0,0,0},
+                    /* 32S -> 32F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32S -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
+                },
+                {
+                    /* 32F ->  8U */ {NppCvt<CV_32F, CV_8U, nppiConvert_32f8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32F ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32F -> 16U */ {NppCvt<CV_32F, CV_16U, nppiConvert_32f16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32F -> 16S */ {NppCvt<CV_32F, CV_16S, nppiConvert_32f16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32F -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 32F -> 32F */ {0,0,0,0},
+                    /* 32F -> 64F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller}
+                },
+                {
+                    /* 64F ->  8U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 64F ->  8S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 64F -> 16U */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 64F -> 16S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 64F -> 32S */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 64F -> 32F */ {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                    /* 64F -> 64F */ {0,0,0,0}
+                }
+            };
+
+            caller_t func = callers[src.depth()][dst.depth()][src.channels() - 1];
+            CV_DbgAssert(func != 0);
+
+            func(src, dst);
+        }
+
+        void convert(const GpuMat& src, GpuMat& dst, double alpha, double beta) const 
+        { 
+            device::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), alpha, beta);
+        }
+
+        void setTo(GpuMat& m, Scalar s, const GpuMat& mask) const
+        {
+            NppiSize sz;
+            sz.width  = m.cols;
+            sz.height = m.rows;
+
+            if (mask.empty())
+            {
+                if (s[0] == 0.0 && s[1] == 0.0 && s[2] == 0.0 && s[3] == 0.0)
+                {
+                    cudaSafeCall( cudaMemset2D(m.data, m.step, 0, m.cols * m.elemSize(), m.rows) );
+                    return;
+                }
+
+                if (m.depth() == CV_8U)
+                {
+                    int cn = m.channels();
+
+                    if (cn == 1 || (cn == 2 && s[0] == s[1]) || (cn == 3 && s[0] == s[1] && s[0] == s[2]) || (cn == 4 && s[0] == s[1] && s[0] == s[2] && s[0] == s[3]))
+                    {
+                        int val = saturate_cast<uchar>(s[0]);
+                        cudaSafeCall( cudaMemset2D(m.data, m.step, val, m.cols * m.elemSize(), m.rows) );
+                        return;
+                    }
+                }
+
+                typedef void (*caller_t)(GpuMat& src, Scalar s);
+                static const caller_t callers[7][4] =
+                {
+                    {NppSet<CV_8U, 1, nppiSet_8u_C1R>::set,kernelSet<uchar>,kernelSet<uchar>,NppSet<CV_8U, 4, nppiSet_8u_C4R>::set},
+                    {kernelSet<schar>,kernelSet<schar>,kernelSet<schar>,kernelSet<schar>},
+                    {NppSet<CV_16U, 1, nppiSet_16u_C1R>::set,NppSet<CV_16U, 2, nppiSet_16u_C2R>::set,kernelSet<ushort>,NppSet<CV_16U, 4, nppiSet_16u_C4R>::set},
+                    {NppSet<CV_16S, 1, nppiSet_16s_C1R>::set,NppSet<CV_16S, 2, nppiSet_16s_C2R>::set,kernelSet<short>,NppSet<CV_16S, 4, nppiSet_16s_C4R>::set},
+                    {NppSet<CV_32S, 1, nppiSet_32s_C1R>::set,kernelSet<int>,kernelSet<int>,NppSet<CV_32S, 4, nppiSet_32s_C4R>::set},
+                    {NppSet<CV_32F, 1, nppiSet_32f_C1R>::set,kernelSet<float>,kernelSet<float>,NppSet<CV_32F, 4, nppiSet_32f_C4R>::set},
+                    {kernelSet<double>,kernelSet<double>,kernelSet<double>,kernelSet<double>}
+                };
+
+                callers[m.depth()][m.channels() - 1](m, s);
+            }
+            else
+            {
+                typedef void (*caller_t)(GpuMat& src, Scalar s, const GpuMat& mask);
+
+                static const caller_t callers[7][4] =
+                {
+                    {NppSetMask<CV_8U, 1, nppiSet_8u_C1MR>::set,kernelSetMask<uchar>,kernelSetMask<uchar>,NppSetMask<CV_8U, 4, nppiSet_8u_C4MR>::set},
+                    {kernelSetMask<schar>,kernelSetMask<schar>,kernelSetMask<schar>,kernelSetMask<schar>},
+                    {NppSetMask<CV_16U, 1, nppiSet_16u_C1MR>::set,kernelSetMask<ushort>,kernelSetMask<ushort>,NppSetMask<CV_16U, 4, nppiSet_16u_C4MR>::set},
+                    {NppSetMask<CV_16S, 1, nppiSet_16s_C1MR>::set,kernelSetMask<short>,kernelSetMask<short>,NppSetMask<CV_16S, 4, nppiSet_16s_C4MR>::set},
+                    {NppSetMask<CV_32S, 1, nppiSet_32s_C1MR>::set,kernelSetMask<int>,kernelSetMask<int>,NppSetMask<CV_32S, 4, nppiSet_32s_C4MR>::set},
+                    {NppSetMask<CV_32F, 1, nppiSet_32f_C1MR>::set,kernelSetMask<float>,kernelSetMask<float>,NppSetMask<CV_32F, 4, nppiSet_32f_C4MR>::set},
+                    {kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>}
+                };
+
+                callers[m.depth()][m.channels() - 1](m, s, mask);
+            }
+        }
+
+        void mallocPitch(void** devPtr, size_t* step, size_t width, size_t height) const
+        {
+            cudaSafeCall( cudaMallocPitch(devPtr, step, width, height) );
+        }
+
+        void free(void* devPtr) const
+        {
+            cudaFree(devPtr);
+        }
+    };
+
+    class Initializer
+    {
+    public:
+        Initializer()
+        {
+            static CudaFuncTable funcTable;
+            setGpuFuncTable(&funcTable);
+        }
+    };
+
+    Initializer init;
+}
+
 #endif
 
diff --git a/modules/gpu/src/match_template.cpp b/modules/gpu/src/match_template.cpp
index e74d0fdc55f26e0019fa8c225c6b69a04f1db525..4e0b4bf6e90cf6889b08b53fb470885b1eabb97b 100644
--- a/modules/gpu/src/match_template.cpp
+++ b/modules/gpu/src/match_template.cpp
@@ -44,6 +44,7 @@
 
 using namespace cv;
 using namespace cv::gpu;
+using namespace std;
 
 #if !defined (HAVE_CUDA)
 
@@ -51,8 +52,10 @@ void cv::gpu::matchTemplate(const GpuMat&, const GpuMat&, GpuMat&, int, Stream&)
 
 #else
 
-namespace cv { namespace gpu { namespace imgproc 
-{  
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace match_template 
+{
     void matchTemplateNaive_CCORR_8U(const DevMem2Db image, const DevMem2Db templ, DevMem2Df result, int cn, cudaStream_t stream);
     void matchTemplateNaive_CCORR_32F(const DevMem2Db image, const DevMem2Db templ, DevMem2Df result, int cn, cudaStream_t stream);
 
@@ -132,8 +135,11 @@ namespace cv { namespace gpu { namespace imgproc
                       unsigned int templ_sqsum, DevMem2Df result, int cn, cudaStream_t stream);
 
     void extractFirstChannel_32F(const DevMem2Db image, DevMem2Df result, int cn, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
+using namespace OPENCV_DEVICE_NAMESPACE_ match_template;
 
 namespace 
 {
@@ -177,14 +183,14 @@ namespace
         result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
         if (templ.size().area() < getTemplateThreshold(CV_TM_CCORR, CV_32F))
         {
-            imgproc::matchTemplateNaive_CCORR_32F(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
+            matchTemplateNaive_CCORR_32F(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
             return;
         }
 
         GpuMat result_;
         ConvolveBuf buf;
         convolve(image.reshape(1), templ.reshape(1), result_, true, buf, stream);
-        imgproc::extractFirstChannel_32F(result_, result, image.channels(), StreamAccessor::getStream(stream));
+        extractFirstChannel_32F(result_, result, image.channels(), StreamAccessor::getStream(stream));
     }
 
 
@@ -193,7 +199,7 @@ namespace
         if (templ.size().area() < getTemplateThreshold(CV_TM_CCORR, CV_8U))
         {
             result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
-            imgproc::matchTemplateNaive_CCORR_8U(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
+            matchTemplateNaive_CCORR_8U(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
             return;
         }
 
@@ -220,15 +226,14 @@ namespace
         sqrIntegral(image.reshape(1), img_sqsum, stream);
 
         unsigned int templ_sqsum = (unsigned int)sqrSum(templ.reshape(1))[0];
-        imgproc::normalize_8U(templ.cols, templ.rows, img_sqsum, templ_sqsum, 
-                              result, image.channels(), StreamAccessor::getStream(stream));
+        normalize_8U(templ.cols, templ.rows, img_sqsum, templ_sqsum, result, image.channels(), StreamAccessor::getStream(stream));
     }
 
     
     void matchTemplate_SQDIFF_32F(const GpuMat& image, const GpuMat& templ, GpuMat& result, Stream& stream)
     {
         result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
-        imgproc::matchTemplateNaive_SQDIFF_32F(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
+        matchTemplateNaive_SQDIFF_32F(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
     }
 
 
@@ -237,7 +242,7 @@ namespace
         if (templ.size().area() < getTemplateThreshold(CV_TM_SQDIFF, CV_8U))
         {
             result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
-            imgproc::matchTemplateNaive_SQDIFF_8U(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
+            matchTemplateNaive_SQDIFF_8U(image, templ, result, image.channels(), StreamAccessor::getStream(stream));
             return;
         }
 
@@ -247,8 +252,7 @@ namespace
         unsigned int templ_sqsum = (unsigned int)sqrSum(templ.reshape(1))[0];
 
         matchTemplate_CCORR_8U(image, templ, result, stream);
-        imgproc::matchTemplatePrepared_SQDIFF_8U(
-                templ.cols, templ.rows, img_sqsum, templ_sqsum, result, image.channels(), StreamAccessor::getStream(stream));
+        matchTemplatePrepared_SQDIFF_8U(templ.cols, templ.rows, img_sqsum, templ_sqsum, result, image.channels(), StreamAccessor::getStream(stream));
     }
 
 
@@ -260,8 +264,7 @@ namespace
         unsigned int templ_sqsum = (unsigned int)sqrSum(templ.reshape(1))[0];
 
         matchTemplate_CCORR_8U(image, templ, result, stream);
-        imgproc::matchTemplatePrepared_SQDIFF_NORMED_8U(
-                templ.cols, templ.rows, img_sqsum, templ_sqsum, result, image.channels(), StreamAccessor::getStream(stream));
+        matchTemplatePrepared_SQDIFF_NORMED_8U(templ.cols, templ.rows, img_sqsum, templ_sqsum, result, image.channels(), StreamAccessor::getStream(stream));
     }
 
 
@@ -275,13 +278,12 @@ namespace
             integral(image, image_sum, stream);
 
             unsigned int templ_sum = (unsigned int)sum(templ)[0];
-            imgproc::matchTemplatePrepared_CCOFF_8U(templ.cols, templ.rows, 
-                                                    image_sum, templ_sum, result, StreamAccessor::getStream(stream));
+            matchTemplatePrepared_CCOFF_8U(templ.cols, templ.rows, image_sum, templ_sum, result, StreamAccessor::getStream(stream));
         }
         else
         {
-            std::vector<GpuMat> images;
-            std::vector<GpuMat> image_sums(image.channels());
+            vector<GpuMat> images;
+            vector<GpuMat> image_sums(image.channels());
 
             split(image, images);
             for (int i = 0; i < image.channels(); ++i)
@@ -292,19 +294,19 @@ namespace
             switch (image.channels())
             {
             case 2:
-                imgproc::matchTemplatePrepared_CCOFF_8UC2(
+                matchTemplatePrepared_CCOFF_8UC2(
                         templ.cols, templ.rows, image_sums[0], image_sums[1],
                         (unsigned int)templ_sum[0], (unsigned int)templ_sum[1],
                         result, StreamAccessor::getStream(stream));
                 break;
             case 3:
-                imgproc::matchTemplatePrepared_CCOFF_8UC3(
+                matchTemplatePrepared_CCOFF_8UC3(
                         templ.cols, templ.rows, image_sums[0], image_sums[1], image_sums[2],
                         (unsigned int)templ_sum[0], (unsigned int)templ_sum[1], (unsigned int)templ_sum[2],
                         result, StreamAccessor::getStream(stream));
                 break;
             case 4:
-                imgproc::matchTemplatePrepared_CCOFF_8UC4(
+                matchTemplatePrepared_CCOFF_8UC4(
                         templ.cols, templ.rows, image_sums[0], image_sums[1], image_sums[2], image_sums[3],
                         (unsigned int)templ_sum[0], (unsigned int)templ_sum[1], (unsigned int)templ_sum[2],
                         (unsigned int)templ_sum[3], result, StreamAccessor::getStream(stream));
@@ -341,15 +343,15 @@ namespace
             unsigned int templ_sum = (unsigned int)sum(templ)[0];
             unsigned int templ_sqsum = (unsigned int)sqrSum(templ)[0];
 
-            imgproc::matchTemplatePrepared_CCOFF_NORMED_8U(
+            matchTemplatePrepared_CCOFF_NORMED_8U(
                     templ.cols, templ.rows, image_sum, image_sqsum, 
                     templ_sum, templ_sqsum, result, StreamAccessor::getStream(stream));
         }
         else
         {
-            std::vector<GpuMat> images;
-            std::vector<GpuMat> image_sums(image.channels());
-            std::vector<GpuMat> image_sqsums(image.channels());
+            vector<GpuMat> images;
+            vector<GpuMat> image_sums(image.channels());
+            vector<GpuMat> image_sqsums(image.channels());
 
             split(image, images);
             for (int i = 0; i < image.channels(); ++i)
@@ -364,7 +366,7 @@ namespace
             switch (image.channels())
             {
             case 2:
-                imgproc::matchTemplatePrepared_CCOFF_NORMED_8UC2(
+                matchTemplatePrepared_CCOFF_NORMED_8UC2(
                         templ.cols, templ.rows, 
                         image_sums[0], image_sqsums[0],
                         image_sums[1], image_sqsums[1],
@@ -373,7 +375,7 @@ namespace
                         result, StreamAccessor::getStream(stream));
                 break;
             case 3:
-                imgproc::matchTemplatePrepared_CCOFF_NORMED_8UC3(
+                matchTemplatePrepared_CCOFF_NORMED_8UC3(
                         templ.cols, templ.rows, 
                         image_sums[0], image_sqsums[0],
                         image_sums[1], image_sqsums[1],
@@ -384,7 +386,7 @@ namespace
                         result, StreamAccessor::getStream(stream));
                 break;
             case 4:
-                imgproc::matchTemplatePrepared_CCOFF_NORMED_8UC4(
+                matchTemplatePrepared_CCOFF_NORMED_8UC4(
                         templ.cols, templ.rows, 
                         image_sums[0], image_sqsums[0],
                         image_sums[1], image_sqsums[1],
diff --git a/modules/gpu/src/matrix_operations.cpp b/modules/gpu/src/matrix_operations.cpp
index 874e6e506df8e06acb292322ed8edcbe07fa11ce..9dd832cb4500e19ee71a462c69846585dcf41230 100644
--- a/modules/gpu/src/matrix_operations.cpp
+++ b/modules/gpu/src/matrix_operations.cpp
@@ -45,6 +45,139 @@
 using namespace cv;
 using namespace cv::gpu;
 
+cv::gpu::CudaMem::CudaMem() 
+    : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0) 
+{
+}
+
+cv::gpu::CudaMem::CudaMem(int _rows, int _cols, int _type, int _alloc_type) 
+    : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
+{
+    if( _rows > 0 && _cols > 0 )
+        create( _rows, _cols, _type, _alloc_type);
+}
+
+cv::gpu::CudaMem::CudaMem(Size _size, int _type, int _alloc_type) 
+    : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
+{
+    if( _size.height > 0 && _size.width > 0 )
+        create( _size.height, _size.width, _type, _alloc_type);
+}
+
+cv::gpu::CudaMem::CudaMem(const CudaMem& m) 
+    : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend), alloc_type(m.alloc_type)
+{
+    if( refcount )
+        CV_XADD(refcount, 1);
+}
+
+cv::gpu::CudaMem::CudaMem(const Mat& m, int _alloc_type) 
+    : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
+{
+    if( m.rows > 0 && m.cols > 0 )
+        create( m.size(), m.type(), _alloc_type);
+
+    Mat tmp = createMatHeader();
+    m.copyTo(tmp);
+}
+
+cv::gpu::CudaMem::~CudaMem()
+{
+    release();
+}
+
+CudaMem& cv::gpu::CudaMem::operator = (const CudaMem& m)
+{
+    if( this != &m )
+    {
+        if( m.refcount )
+            CV_XADD(m.refcount, 1);
+        release();
+        flags = m.flags;
+        rows = m.rows; cols = m.cols;
+        step = m.step; data = m.data;
+        datastart = m.datastart;
+        dataend = m.dataend;
+        refcount = m.refcount;
+        alloc_type = m.alloc_type;
+    }
+    return *this;
+}
+
+CudaMem cv::gpu::CudaMem::clone() const
+{
+    CudaMem m(size(), type(), alloc_type);
+    Mat to = m;
+    Mat from = *this;
+    from.copyTo(to);
+    return m;
+}
+
+void cv::gpu::CudaMem::create(Size _size, int _type, int _alloc_type) 
+{ 
+    create(_size.height, _size.width, _type, _alloc_type); 
+}
+
+Mat cv::gpu::CudaMem::createMatHeader() const 
+{ 
+    return Mat(size(), type(), data, step); 
+}
+
+cv::gpu::CudaMem::operator Mat() const 
+{ 
+    return createMatHeader(); 
+}
+
+cv::gpu::CudaMem::operator GpuMat() const 
+{ 
+    return createGpuMatHeader(); 
+}
+
+bool cv::gpu::CudaMem::isContinuous() const 
+{ 
+    return (flags & Mat::CONTINUOUS_FLAG) != 0; 
+}
+
+size_t cv::gpu::CudaMem::elemSize() const 
+{ 
+    return CV_ELEM_SIZE(flags); 
+}
+
+size_t cv::gpu::CudaMem::elemSize1() const 
+{ 
+    return CV_ELEM_SIZE1(flags); 
+}
+
+int cv::gpu::CudaMem::type() const 
+{ 
+    return CV_MAT_TYPE(flags); 
+}
+
+int cv::gpu::CudaMem::depth() const 
+{ 
+    return CV_MAT_DEPTH(flags); 
+}
+
+int cv::gpu::CudaMem::channels() const 
+{ 
+    return CV_MAT_CN(flags); 
+}
+
+size_t cv::gpu::CudaMem::step1() const 
+{ 
+    return step/elemSize1(); 
+}
+
+Size cv::gpu::CudaMem::size() const 
+{ 
+    return Size(cols, rows); 
+}
+
+bool cv::gpu::CudaMem::empty() const 
+{ 
+    return data == 0; 
+}
+
 #if !defined (HAVE_CUDA)
 
 void cv::gpu::registerPageLocked(Mat&) { throw_nogpu(); }
diff --git a/modules/gpu/src/matrix_reductions.cpp b/modules/gpu/src/matrix_reductions.cpp
index 60c3ed92c53c2d098e684bf50710319722d67b4a..3450bd83ffb810fcf3e9b9a9099366f68410c164 100644
--- a/modules/gpu/src/matrix_reductions.cpp
+++ b/modules/gpu/src/matrix_reductions.cpp
@@ -190,32 +190,35 @@ double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType)
 ////////////////////////////////////////////////////////////////////////
 // Sum
 
-namespace cv { namespace gpu { namespace mathfunc
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace matrix_reductions 
 {
-    template <typename T>
-    void sumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
+    namespace sum
+    {
+        template <typename T>
+        void sumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
 
-    template <typename T>
-    void sumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
+        template <typename T>
+        void sumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
 
-    template <typename T>
-    void absSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
+        template <typename T>
+        void absSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
 
-    template <typename T>
-    void absSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
+        template <typename T>
+        void absSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
 
-    template <typename T>
-    void sqrSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
+        template <typename T>
+        void sqrSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
 
-    template <typename T>
-    void sqrSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
+        template <typename T>
+        void sqrSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn);
 
-    namespace sums
-    {
         void getBufSizeRequired(int cols, int rows, int cn, int& bufcols, int& bufrows);
     }
-}}}
+}
 
+END_OPENCV_DEVICE_NAMESPACE
 
 Scalar cv::gpu::sum(const GpuMat& src) 
 {
@@ -226,23 +229,25 @@ Scalar cv::gpu::sum(const GpuMat& src)
 
 Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf) 
 {
-    using namespace mathfunc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ matrix_reductions::sum;
 
     typedef void (*Caller)(const DevMem2Db, PtrStepb, double*, int);
 
-    static Caller multipass_callers[7] = { 
-            sumMultipassCaller<unsigned char>, sumMultipassCaller<char>, 
-            sumMultipassCaller<unsigned short>, sumMultipassCaller<short>, 
-            sumMultipassCaller<int>, sumMultipassCaller<float>, 0 };
+    static Caller multipass_callers[7] = 
+    { 
+        sumMultipassCaller<unsigned char>, sumMultipassCaller<char>, 
+        sumMultipassCaller<unsigned short>, sumMultipassCaller<short>, 
+        sumMultipassCaller<int>, sumMultipassCaller<float>, 0 
+    };
 
     static Caller singlepass_callers[7] = { 
-            sumCaller<unsigned char>, sumCaller<char>, 
-            sumCaller<unsigned short>, sumCaller<short>, 
-            sumCaller<int>, sumCaller<float>, 0 };
+        sumCaller<unsigned char>, sumCaller<char>, 
+        sumCaller<unsigned short>, sumCaller<short>, 
+        sumCaller<int>, sumCaller<float>, 0 
+    };
 
     Size buf_size;
-    sums::getBufSizeRequired(src.cols, src.rows, src.channels(), 
-                             buf_size.width, buf_size.height); 
+    getBufSizeRequired(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height); 
     ensureSizeIsEnough(buf_size, CV_8U, buf);
 
     Caller* callers = multipass_callers;
@@ -267,23 +272,26 @@ Scalar cv::gpu::absSum(const GpuMat& src)
 
 Scalar cv::gpu::absSum(const GpuMat& src, GpuMat& buf) 
 {
-    using namespace mathfunc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ matrix_reductions::sum;
 
     typedef void (*Caller)(const DevMem2Db, PtrStepb, double*, int);
 
-    static Caller multipass_callers[7] = { 
-            absSumMultipassCaller<unsigned char>, absSumMultipassCaller<char>, 
-            absSumMultipassCaller<unsigned short>, absSumMultipassCaller<short>, 
-            absSumMultipassCaller<int>, absSumMultipassCaller<float>, 0 };
+    static Caller multipass_callers[7] = 
+    { 
+        absSumMultipassCaller<unsigned char>, absSumMultipassCaller<char>, 
+        absSumMultipassCaller<unsigned short>, absSumMultipassCaller<short>, 
+        absSumMultipassCaller<int>, absSumMultipassCaller<float>, 0 
+    };
 
-    static Caller singlepass_callers[7] = { 
-            absSumCaller<unsigned char>, absSumCaller<char>, 
-            absSumCaller<unsigned short>, absSumCaller<short>, 
-            absSumCaller<int>, absSumCaller<float>, 0 };
+    static Caller singlepass_callers[7] = 
+    {        
+        absSumCaller<unsigned char>, absSumCaller<char>, 
+        absSumCaller<unsigned short>, absSumCaller<short>, 
+        absSumCaller<int>, absSumCaller<float>, 0 
+    };
 
     Size buf_size;
-    sums::getBufSizeRequired(src.cols, src.rows, src.channels(), 
-                             buf_size.width, buf_size.height); 
+    getBufSizeRequired(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height); 
     ensureSizeIsEnough(buf_size, CV_8U, buf);
 
     Caller* callers = multipass_callers;
@@ -308,27 +316,30 @@ Scalar cv::gpu::sqrSum(const GpuMat& src)
 
 Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf) 
 {
-    using namespace mathfunc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ matrix_reductions::sum;
 
     typedef void (*Caller)(const DevMem2Db, PtrStepb, double*, int);
 
-    static Caller multipass_callers[7] = { 
-            sqrSumMultipassCaller<unsigned char>, sqrSumMultipassCaller<char>, 
-            sqrSumMultipassCaller<unsigned short>, sqrSumMultipassCaller<short>, 
-            sqrSumMultipassCaller<int>, sqrSumMultipassCaller<float>, 0 };
+    static Caller multipass_callers[7] = 
+    { 
+        sqrSumMultipassCaller<unsigned char>, sqrSumMultipassCaller<char>, 
+        sqrSumMultipassCaller<unsigned short>, sqrSumMultipassCaller<short>, 
+        sqrSumMultipassCaller<int>, sqrSumMultipassCaller<float>, 0 
+    };
 
-    static Caller singlepass_callers[7] = { 
-            sqrSumCaller<unsigned char>, sqrSumCaller<char>, 
-            sqrSumCaller<unsigned short>, sqrSumCaller<short>, 
-            sqrSumCaller<int>, sqrSumCaller<float>, 0 };
+    static Caller singlepass_callers[7] = 
+    { 
+        sqrSumCaller<unsigned char>, sqrSumCaller<char>, 
+        sqrSumCaller<unsigned short>, sqrSumCaller<short>, 
+        sqrSumCaller<int>, sqrSumCaller<float>, 0 
+    };
 
     Caller* callers = multipass_callers;
     if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
         callers = singlepass_callers;
 
     Size buf_size;
-    sums::getBufSizeRequired(src.cols, src.rows, src.channels(), 
-                             buf_size.width, buf_size.height); 
+    getBufSizeRequired(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height); 
     ensureSizeIsEnough(buf_size, CV_8U, buf);
 
     Caller caller = callers[src.depth()];
@@ -339,29 +350,32 @@ Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf)
     return Scalar(result[0], result[1], result[2], result[3]);
 }
 
-
-
-
 ////////////////////////////////////////////////////////////////////////
 // Find min or max
 
-namespace cv { namespace gpu { namespace mathfunc { namespace minmax {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    void getBufSizeRequired(int cols, int rows, int elem_size, int& bufcols, int& bufrows);
-    
-    template <typename T> 
-    void minMaxCaller(const DevMem2Db src, double* minval, double* maxval, PtrStepb buf);
+namespace matrix_reductions 
+{
+    namespace minmax 
+    {
+        void getBufSizeRequired(int cols, int rows, int elem_size, int& bufcols, int& bufrows);
+        
+        template <typename T> 
+        void minMaxCaller(const DevMem2Db src, double* minval, double* maxval, PtrStepb buf);
 
-    template <typename T> 
-    void minMaxMaskCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+        template <typename T> 
+        void minMaxMaskCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
 
-    template <typename T> 
-    void minMaxMultipassCaller(const DevMem2Db src, double* minval, double* maxval, PtrStepb buf);
+        template <typename T> 
+        void minMaxMultipassCaller(const DevMem2Db src, double* minval, double* maxval, PtrStepb buf);
 
-    template <typename T> 
-    void minMaxMaskMultipassCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+        template <typename T> 
+        void minMaxMaskMultipassCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    }
+}
 
-}}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 
 void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask)
@@ -373,39 +387,43 @@ void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const Gp
 
 void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf)
 {
-    using namespace mathfunc::minmax;
+    using namespace OPENCV_DEVICE_NAMESPACE_ matrix_reductions::minmax;
 
     typedef void (*Caller)(const DevMem2Db, double*, double*, PtrStepb);
     typedef void (*MaskedCaller)(const DevMem2Db, const PtrStepb, double*, double*, PtrStepb);
 
-    static Caller multipass_callers[7] = { 
-            minMaxMultipassCaller<unsigned char>, minMaxMultipassCaller<char>, 
-            minMaxMultipassCaller<unsigned short>, minMaxMultipassCaller<short>, 
-            minMaxMultipassCaller<int>, minMaxMultipassCaller<float>, 0 };
+    static Caller multipass_callers[7] = 
+    { 
+        minMaxMultipassCaller<unsigned char>, minMaxMultipassCaller<char>, 
+        minMaxMultipassCaller<unsigned short>, minMaxMultipassCaller<short>, 
+        minMaxMultipassCaller<int>, minMaxMultipassCaller<float>, 0 
+    };
 
-    static Caller singlepass_callers[7] = { 
-            minMaxCaller<unsigned char>, minMaxCaller<char>, 
-            minMaxCaller<unsigned short>, minMaxCaller<short>, 
-            minMaxCaller<int>, minMaxCaller<float>, minMaxCaller<double> };
+    static Caller singlepass_callers[7] = 
+    { 
+        minMaxCaller<unsigned char>, minMaxCaller<char>, 
+        minMaxCaller<unsigned short>, minMaxCaller<short>, 
+        minMaxCaller<int>, minMaxCaller<float>, minMaxCaller<double> 
+    };
 
-    static MaskedCaller masked_multipass_callers[7] = { 
-            minMaxMaskMultipassCaller<unsigned char>, minMaxMaskMultipassCaller<char>, 
-            minMaxMaskMultipassCaller<unsigned short>, minMaxMaskMultipassCaller<short>,
-            minMaxMaskMultipassCaller<int>, minMaxMaskMultipassCaller<float>, 0 };
+    static MaskedCaller masked_multipass_callers[7] = 
+    { 
+        minMaxMaskMultipassCaller<unsigned char>, minMaxMaskMultipassCaller<char>, 
+        minMaxMaskMultipassCaller<unsigned short>, minMaxMaskMultipassCaller<short>,
+        minMaxMaskMultipassCaller<int>, minMaxMaskMultipassCaller<float>, 0
+    };
 
-    static MaskedCaller masked_singlepass_callers[7] = { 
-            minMaxMaskCaller<unsigned char>, minMaxMaskCaller<char>, 
-            minMaxMaskCaller<unsigned short>, minMaxMaskCaller<short>, 
-            minMaxMaskCaller<int>, minMaxMaskCaller<float>, 
-            minMaxMaskCaller<double> };
+    static MaskedCaller masked_singlepass_callers[7] =
+    { 
+        minMaxMaskCaller<unsigned char>, minMaxMaskCaller<char>, 
+        minMaxMaskCaller<unsigned short>, minMaxMaskCaller<short>, 
+        minMaxMaskCaller<int>, minMaxMaskCaller<float>, minMaxMaskCaller<double> 
+    };
 
     CV_Assert(src.channels() == 1);
 
     CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
 
-    CV_Assert(src.type() != CV_64F || (TargetArchs::builtWith(NATIVE_DOUBLE) && 
-                                       DeviceInfo().supports(NATIVE_DOUBLE)));
-
     double minVal_; if (!minVal) minVal = &minVal_;
     double maxVal_; if (!maxVal) maxVal = &maxVal_;
     
@@ -439,28 +457,34 @@ void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const Gp
 ////////////////////////////////////////////////////////////////////////
 // Locate min and max
 
-namespace cv { namespace gpu { namespace mathfunc { namespace minmaxloc {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    void getBufSizeRequired(int cols, int rows, int elem_size, int& b1cols, 
-                               int& b1rows, int& b2cols, int& b2rows);
+namespace matrix_reductions 
+{
+    namespace minmaxloc 
+    {
+        void getBufSizeRequired(int cols, int rows, int elem_size, int& b1cols, 
+                                int& b1rows, int& b2cols, int& b2rows);
 
-    template <typename T> 
-    void minMaxLocCaller(const DevMem2Db src, double* minval, double* maxval, 
-                            int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
+        template <typename T> 
+        void minMaxLocCaller(const DevMem2Db src, double* minval, double* maxval, 
+                             int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
 
-    template <typename T> 
-    void minMaxLocMaskCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, 
+        template <typename T> 
+        void minMaxLocMaskCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, 
                                  int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
 
-    template <typename T> 
-    void minMaxLocMultipassCaller(const DevMem2Db src, double* minval, double* maxval, 
-                                     int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
+        template <typename T> 
+        void minMaxLocMultipassCaller(const DevMem2Db src, double* minval, double* maxval, 
+                                      int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
 
-    template <typename T> 
-    void minMaxLocMaskMultipassCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, 
-                                           int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
-}}}}
+        template <typename T> 
+        void minMaxLocMaskMultipassCaller(const DevMem2Db src, const PtrStepb mask, double* minval, double* maxval, 
+                                          int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
+    }
+}
 
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask)
 {    
@@ -468,43 +492,46 @@ void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point
     minMaxLoc(src, minVal, maxVal, minLoc, maxLoc, mask, valBuf, locBuf);
 }
 
-
 void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
                         const GpuMat& mask, GpuMat& valBuf, GpuMat& locBuf)
 {
-    using namespace mathfunc::minmaxloc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ matrix_reductions::minmaxloc;
 
     typedef void (*Caller)(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
     typedef void (*MaskedCaller)(const DevMem2Db, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
 
-    static Caller multipass_callers[7] = { 
-            minMaxLocMultipassCaller<unsigned char>, minMaxLocMultipassCaller<char>, 
-            minMaxLocMultipassCaller<unsigned short>, minMaxLocMultipassCaller<short>, 
-            minMaxLocMultipassCaller<int>, minMaxLocMultipassCaller<float>, 0 };
+    static Caller multipass_callers[7] = 
+    {
+        minMaxLocMultipassCaller<unsigned char>, minMaxLocMultipassCaller<char>, 
+        minMaxLocMultipassCaller<unsigned short>, minMaxLocMultipassCaller<short>, 
+        minMaxLocMultipassCaller<int>, minMaxLocMultipassCaller<float>, 0 
+    };
 
-    static Caller singlepass_callers[7] = { 
-            minMaxLocCaller<unsigned char>, minMaxLocCaller<char>, 
-            minMaxLocCaller<unsigned short>, minMaxLocCaller<short>, 
-            minMaxLocCaller<int>, minMaxLocCaller<float>, minMaxLocCaller<double> };
+    static Caller singlepass_callers[7] = 
+    {
+        minMaxLocCaller<unsigned char>, minMaxLocCaller<char>, 
+        minMaxLocCaller<unsigned short>, minMaxLocCaller<short>, 
+        minMaxLocCaller<int>, minMaxLocCaller<float>, minMaxLocCaller<double> 
+    };
 
-    static MaskedCaller masked_multipass_callers[7] = { 
-            minMaxLocMaskMultipassCaller<unsigned char>, minMaxLocMaskMultipassCaller<char>, 
-            minMaxLocMaskMultipassCaller<unsigned short>, minMaxLocMaskMultipassCaller<short>, 
-            minMaxLocMaskMultipassCaller<int>, minMaxLocMaskMultipassCaller<float>, 0 };
+    static MaskedCaller masked_multipass_callers[7] = 
+    {
+        minMaxLocMaskMultipassCaller<unsigned char>, minMaxLocMaskMultipassCaller<char>,
+        minMaxLocMaskMultipassCaller<unsigned short>, minMaxLocMaskMultipassCaller<short>, 
+        minMaxLocMaskMultipassCaller<int>, minMaxLocMaskMultipassCaller<float>, 0 
+    };
 
-    static MaskedCaller masked_singlepass_callers[7] = { 
-            minMaxLocMaskCaller<unsigned char>, minMaxLocMaskCaller<char>, 
-            minMaxLocMaskCaller<unsigned short>, minMaxLocMaskCaller<short>, 
-            minMaxLocMaskCaller<int>, minMaxLocMaskCaller<float>, 
-            minMaxLocMaskCaller<double> };
+    static MaskedCaller masked_singlepass_callers[7] = 
+    { 
+        minMaxLocMaskCaller<unsigned char>, minMaxLocMaskCaller<char>, 
+        minMaxLocMaskCaller<unsigned short>, minMaxLocMaskCaller<short>, 
+        minMaxLocMaskCaller<int>, minMaxLocMaskCaller<float>, minMaxLocMaskCaller<double> 
+    };
 
     CV_Assert(src.channels() == 1);
 
     CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
 
-    CV_Assert(src.type() != CV_64F || (TargetArchs::builtWith(NATIVE_DOUBLE) && 
-                                       DeviceInfo().supports(NATIVE_DOUBLE)));
-
     double minVal_; if (!minVal) minVal = &minVal_;
     double maxVal_; if (!maxVal) maxVal = &maxVal_;
     int minLoc_[2];
@@ -544,18 +571,23 @@ void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point
 //////////////////////////////////////////////////////////////////////////////
 // Count non-zero elements
 
-namespace cv { namespace gpu { namespace mathfunc { namespace countnonzero {
-
-    void getBufSizeRequired(int cols, int rows, int& bufcols, int& bufrows);
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T> 
-    int countNonZeroCaller(const DevMem2Db src, PtrStepb buf);
+namespace matrix_reductions 
+{
+    namespace countnonzero 
+    {
+        void getBufSizeRequired(int cols, int rows, int& bufcols, int& bufrows);
 
-    template <typename T> 
-    int countNonZeroMultipassCaller(const DevMem2Db src, PtrStepb buf);
+        template <typename T> 
+        int countNonZeroCaller(const DevMem2Db src, PtrStepb buf);
 
-}}}}
+        template <typename T> 
+        int countNonZeroMultipassCaller(const DevMem2Db src, PtrStepb buf);
+    }
+}
 
+END_OPENCV_DEVICE_NAMESPACE
 
 int cv::gpu::countNonZero(const GpuMat& src)
 {
@@ -566,26 +598,25 @@ int cv::gpu::countNonZero(const GpuMat& src)
 
 int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
 {
-    using namespace mathfunc::countnonzero;
+    using namespace OPENCV_DEVICE_NAMESPACE_ matrix_reductions::countnonzero;
 
     typedef int (*Caller)(const DevMem2Db src, PtrStepb buf);
 
-    static Caller multipass_callers[7] = { 
-            countNonZeroMultipassCaller<unsigned char>, countNonZeroMultipassCaller<char>,
-            countNonZeroMultipassCaller<unsigned short>, countNonZeroMultipassCaller<short>,
-            countNonZeroMultipassCaller<int>, countNonZeroMultipassCaller<float>, 0 };
+    static Caller multipass_callers[7] = 
+    {
+        countNonZeroMultipassCaller<unsigned char>, countNonZeroMultipassCaller<char>,
+        countNonZeroMultipassCaller<unsigned short>, countNonZeroMultipassCaller<short>,
+        countNonZeroMultipassCaller<int>, countNonZeroMultipassCaller<float>, 0 
+    };
 
-    static Caller singlepass_callers[7] = { 
-            countNonZeroCaller<unsigned char>, countNonZeroCaller<char>,
-            countNonZeroCaller<unsigned short>, countNonZeroCaller<short>,
-            countNonZeroCaller<int>, countNonZeroCaller<float>, 
-            countNonZeroCaller<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.channels() == 1);
 
-    CV_Assert(src.type() != CV_64F || (TargetArchs::builtWith(NATIVE_DOUBLE) && 
-                                       DeviceInfo().supports(NATIVE_DOUBLE)));
-
     Size buf_size;
     getBufSizeRequired(src.cols, src.rows, buf_size.width, buf_size.height);
     ensureSizeIsEnough(buf_size, CV_8U, buf);
@@ -601,15 +632,20 @@ int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
 
 //////////////////////////////////////////////////////////////////////////////
 // reduce
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace mathfunc {
+namespace matrix_reductions 
+{
     template <typename T, typename S, typename D> void reduceRows_gpu(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
     template <typename T, typename S, typename D> void reduceCols_gpu(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 void cv::gpu::reduce(const GpuMat& src, GpuMat& dst, int dim, int reduceOp, int dtype, Stream& stream)
 {
-    using namespace cv::gpu::mathfunc;
+    using namespace OPENCV_DEVICE_NAMESPACE_ 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);
diff --git a/modules/gpu/src/mssegmentation.cpp b/modules/gpu/src/mssegmentation.cpp
index 609fdda7c8adac193f947626047585fe28f5f331..b5b7bac273ae66c6ef7ab7525e284a8db948f0c4 100644
--- a/modules/gpu/src/mssegmentation.cpp
+++ b/modules/gpu/src/mssegmentation.cpp
@@ -234,10 +234,10 @@ void cv::gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr,
     const int hsp = sp;
 
     // Perform mean shift procedure and obtain region and spatial maps
-    GpuMat h_rmap, h_spmap;
-    meanShiftProc(src, h_rmap, h_spmap, sp, sr, criteria);
-    Mat rmap = h_rmap;
-    Mat spmap = h_spmap;
+    GpuMat d_rmap, d_spmap;
+    meanShiftProc(src, d_rmap, d_spmap, sp, sr, criteria);
+    Mat rmap(d_rmap);
+    Mat spmap(d_spmap);
 
     Graph<SegmLinkVal> g(nrows * ncols, 4 * (nrows - 1) * (ncols - 1)
                                         + (nrows - 1) + (ncols - 1));
@@ -352,7 +352,7 @@ void cv::gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr,
     }
 
     // Compute sum of the pixel's colors which are in the same segment
-    Mat h_src = src;
+    Mat h_src(src);
     vector<Vec4i> sumcols(nrows * ncols, Vec4i(0, 0, 0, 0));
     for (int y = 0; y < nrows; ++y)
     {
diff --git a/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp b/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp
index 2888a52f371138c820ee4a9f4c286762b4fcec56..bf952d813b00908f7be9fab302514577cb5ec074 100644
--- a/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp
@@ -43,672 +43,674 @@
 #ifndef __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
 #define __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
 
+#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "vec_traits.hpp"
 #include "vec_math.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+//////////////////////////////////////////////////////////////
+// BrdConstant
+
+template <typename D> struct BrdRowConstant
+{
+    typedef D result_type;
+
+    explicit __host__ __device__ __forceinline__ BrdRowConstant(int width_, const D& val_ = VecTraits<D>::all(0)) : width(width_), val(val_) {}
+
+    template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
+    {
+        return x >= 0 ? saturate_cast<D>(data[x]) : val;
+    }
+
+    template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
+    {
+        return x < width ? saturate_cast<D>(data[x]) : val;
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
+    {
+        return (x >= 0 && x < width) ? saturate_cast<D>(data[x]) : val;
+    }
+
+    const int width;
+    const D val;
+};
+
+template <typename D> struct BrdColConstant
+{
+    typedef D result_type;
+
+    explicit __host__ __device__ __forceinline__ BrdColConstant(int height_, const D& val_ = VecTraits<D>::all(0)) : height(height_), val(val_) {}
+
+    template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
+    {
+        return y >= 0 ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
+    }
+
+    template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
+    {
+        return y < height ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
+    {
+        return (y >= 0 && y < height) ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
+    }
+
+    const int height;
+    const D val;
+};
+
+template <typename D> struct BrdConstant
+{
+    typedef D result_type;
+
+    __host__ __device__ __forceinline__ BrdConstant(int height_, int width_, const D& val_ = VecTraits<D>::all(0)) : height(height_), width(width_), val(val_) 
+    {
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const
+    {
+        return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(((const T*)((const uchar*)data + y * step))[x]) : val;
+    }
+
+    template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const
+    {
+        return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(src(y, x)) : val;
+    }
+
+    const int height;
+    const int width;
+    const D val;
+};
+
+//////////////////////////////////////////////////////////////
+// BrdReplicate
+
+template <typename D> struct BrdRowReplicate
+{
+    typedef D result_type;
+
+    explicit __host__ __device__ __forceinline__ BrdRowReplicate(int width) : last_col(width - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdRowReplicate(int width, U) : last_col(width - 1) {}
+
+    __device__ __forceinline__ int idx_col_low(int x) const
+    {
+        return ::max(x, 0);
+    }
+
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return ::min(x, last_col);
+    }
+
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_low(idx_col_high(x));
+    }
+
+    template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col_low(x)]);
+    }
+
+    template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col_high(x)]);
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col(x)]);
+    }
+
+    const int last_col;
+};
+
+template <typename D> struct BrdColReplicate
+{
+    typedef D result_type;
+
+    explicit __host__ __device__ __forceinline__ BrdColReplicate(int height) : last_row(height - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdColReplicate(int height, U) : last_row(height - 1) {}
+
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return ::max(y, 0);
+    }
+
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return ::min(y, last_row);
+    }
+
+    __device__ __forceinline__ int idx_row(int y) const
+    {
+        return idx_row_low(idx_row_high(y));
+    }
+
+    template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const T*)((const char*)data + idx_row_low(y) * step));
+    }
+
+    template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const T*)((const char*)data + idx_row_high(y) * step));
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const T*)((const char*)data + idx_row(y) * step));
+    }
+
+    const int last_row;
+};
+
+template <typename D> struct BrdReplicate
+{
+    typedef D result_type;
+
+    __host__ __device__ __forceinline__ BrdReplicate(int height, int width) : last_row(height - 1), last_col(width - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdReplicate(int height, int width, U) : last_row(height - 1), last_col(width - 1) {}
+
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return ::max(y, 0);
+    }
+
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return ::min(y, last_row);
+    }
+
+    __device__ __forceinline__ int idx_row(int y) const
+    {
+        return idx_row_low(idx_row_high(y));
+    }
+
+    __device__ __forceinline__ int idx_col_low(int x) const
+    {
+        return ::max(x, 0);
+    }
+
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return ::min(x, last_col);
+    }
+
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_low(idx_col_high(x));
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
+    }
+
+    template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
+    {
+        return saturate_cast<D>(src(idx_row(y), idx_col(x)));
+    }
+
+    const int last_row;
+    const int last_col;
+};
+
+//////////////////////////////////////////////////////////////
+// BrdReflect101
+
+template <typename D> struct BrdRowReflect101
 {
-    //////////////////////////////////////////////////////////////
-    // BrdConstant
+    typedef D result_type;
+
+    explicit __host__ __device__ __forceinline__ BrdRowReflect101(int width) : last_col(width - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdRowReflect101(int width, U) : last_col(width - 1) {}
 
-    template <typename D> struct BrdRowConstant
+    __device__ __forceinline__ int idx_col_low(int x) const
     {
-        typedef D result_type;
+        return ::abs(x) % (last_col + 1);
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdRowConstant(int width_, const D& val_ = VecTraits<D>::all(0)) : width(width_), val(val_) {}
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return ::abs(last_col - ::abs(last_col - x)) % (last_col + 1);
+    }
 
-        template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
-        {
-            return x >= 0 ? saturate_cast<D>(data[x]) : val;
-        }
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_low(idx_col_high(x));
+    }
 
-        template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
-        {
-            return x < width ? saturate_cast<D>(data[x]) : val;
-        }
+    template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col_low(x)]);
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
-        {
-            return (x >= 0 && x < width) ? saturate_cast<D>(data[x]) : val;
-        }
+    template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col_high(x)]);
+    }
+
+    template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col(x)]);
+    }
 
-        const int width;
-        const D val;
-    };
+    const int last_col;
+};
+
+template <typename D> struct BrdColReflect101
+{
+    typedef D result_type;
 
-    template <typename D> struct BrdColConstant
+    explicit __host__ __device__ __forceinline__ BrdColReflect101(int height) : last_row(height - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdColReflect101(int height, U) : last_row(height - 1) {}
+
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return ::abs(y) % (last_row + 1);
+    }
+
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return ::abs(last_row - ::abs(last_row - y)) % (last_row + 1);
+    }
+
+    __device__ __forceinline__ int idx_row(int y) const
     {
-        typedef D result_type;
+        return idx_row_low(idx_row_high(y));
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdColConstant(int height_, const D& val_ = VecTraits<D>::all(0)) : height(height_), val(val_) {}
+    template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row_low(y) * step));
+    }
 
-        template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
-        {
-            return y >= 0 ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
-        }
+    template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row_high(y) * step));
+    }
 
-        template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
-        {
-            return y < height ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
-        }
+    template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
-        {
-            return (y >= 0 && y < height) ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
-        }
+    const int last_row;
+};
+
+template <typename D> struct BrdReflect101
+{
+    typedef D result_type;
 
-        const int height;
-        const D val;
-    };
+    __host__ __device__ __forceinline__ BrdReflect101(int height, int width) : last_row(height - 1), last_col(width - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdReflect101(int height, int width, U) : last_row(height - 1), last_col(width - 1) {}
 
-    template <typename D> struct BrdConstant
+    __device__ __forceinline__ int idx_row_low(int y) const
     {
-        typedef D result_type;
+        return ::abs(y) % (last_row + 1);
+    }
 
-        __host__ __device__ __forceinline__ BrdConstant(int height_, int width_, const D& val_ = VecTraits<D>::all(0)) : height(height_), width(width_), val(val_) 
-        {
-        }
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return ::abs(last_row - ::abs(last_row - y)) % (last_row + 1);
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const
-        {
-            return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(((const T*)((const uchar*)data + y * step))[x]) : val;
-        }
+    __device__ __forceinline__ int idx_row(int y) const
+    {
+        return idx_row_low(idx_row_high(y));
+    }
 
-        template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const
-        {
-            return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(src(y, x)) : val;
-        }
+    __device__ __forceinline__ int idx_col_low(int x) const
+    {
+        return ::abs(x) % (last_col + 1);
+    }
 
-        const int height;
-        const int width;
-        const D val;
-    };
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return ::abs(last_col - ::abs(last_col - x)) % (last_col + 1);
+    }
 
-    //////////////////////////////////////////////////////////////
-    // BrdReplicate
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_low(idx_col_high(x));
+    }
 
-    template <typename D> struct BrdRowReplicate
+    template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
     {
-        typedef D result_type;
+        return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdRowReplicate(int width) : last_col(width - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdRowReplicate(int width, U) : last_col(width - 1) {}
+    template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
+    {
+        return saturate_cast<D>(src(idx_row(y), idx_col(x)));
+    }
 
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return ::max(x, 0);
-        }
+    const int last_row;
+    const int last_col;
+};
 
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return ::min(x, last_col);
-        }
+//////////////////////////////////////////////////////////////
+// BrdReflect
 
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_low(idx_col_high(x));
-        }
+template <typename D> struct BrdRowReflect
+{
+    typedef D result_type;
 
-        template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_low(x)]);
-        }
+    explicit __host__ __device__ __forceinline__ BrdRowReflect(int width) : last_col(width - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdRowReflect(int width, U) : last_col(width - 1) {}
 
-        template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_high(x)]);
-        }
+    __device__ __forceinline__ int idx_col_low(int x) const
+    {
+        return (::abs(x) - (x < 0)) % (last_col + 1);
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col(x)]);
-        }
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return ::abs(last_col - ::abs(last_col - x) + (x > last_col)) % (last_col + 1);
+    }
 
-        const int last_col;
-    };
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_low(idx_col_high(x));
+    }
 
-    template <typename D> struct BrdColReplicate
+    template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
     {
-        typedef D result_type;
+        return saturate_cast<D>(data[idx_col_low(x)]);
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdColReplicate(int height) : last_row(height - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdColReplicate(int height, U) : last_row(height - 1) {}
+    template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col_high(x)]);
+    }
 
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return ::max(y, 0);
-        }
+    template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col(x)]);
+    }
 
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return ::min(y, last_row);
-        }
+    const int last_col;
+};
 
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_low(idx_row_high(y));
-        }
+template <typename D> struct BrdColReflect
+{
+    typedef D result_type;
 
-        template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const T*)((const char*)data + idx_row_low(y) * step));
-        }
+    explicit __host__ __device__ __forceinline__ BrdColReflect(int height) : last_row(height - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdColReflect(int height, U) : last_row(height - 1) {}
 
-        template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const T*)((const char*)data + idx_row_high(y) * step));
-        }
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return (::abs(y) - (y < 0)) % (last_row + 1);
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const T*)((const char*)data + idx_row(y) * step));
-        }
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return ::abs(last_row - ::abs(last_row - y) + (y > last_row)) % (last_row + 1);
+    }
 
-        const int last_row;
-    };
+    __device__ __forceinline__ int idx_row(int y) const
+    {
+        return idx_row_low(idx_row_high(y));
+    }
 
-    template <typename D> struct BrdReplicate
+    template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
     {
-        typedef D result_type;
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row_low(y) * step));
+    }
 
-        __host__ __device__ __forceinline__ BrdReplicate(int height, int width) : last_row(height - 1), last_col(width - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdReplicate(int height, int width, U) : last_row(height - 1), last_col(width - 1) {}
+    template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row_high(y) * step));
+    }
 
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return ::max(y, 0);
-        }
+    template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
+    }
 
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return ::min(y, last_row);
-        }
+    const int last_row;
+};
 
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_low(idx_row_high(y));
-        }
+template <typename D> struct BrdReflect
+{
+    typedef D result_type;
 
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return ::max(x, 0);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return ::min(x, last_col);
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_low(idx_col_high(x));
-        }
+    __host__ __device__ __forceinline__ BrdReflect(int height, int width) : last_row(height - 1), last_col(width - 1) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdReflect(int height, int width, U) : last_row(height - 1), last_col(width - 1) {}
 
-        template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
-        }
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return (::abs(y) - (y < 0)) % (last_row + 1);
+    }
 
-        template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
-        {
-            return saturate_cast<D>(src(idx_row(y), idx_col(x)));
-        }
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return /*::abs*/(last_row - ::abs(last_row - y) + (y > last_row)) /*% (last_row + 1)*/;
+    }
 
-        const int last_row;
-        const int last_col;
-    };
+    __device__ __forceinline__ int idx_row(int y) const
+    {
+        return idx_row_low(idx_row_high(y));
+    }
+
+    __device__ __forceinline__ int idx_col_low(int x) const
+    {
+        return (::abs(x) - (x < 0)) % (last_col + 1);
+    }
 
-    //////////////////////////////////////////////////////////////
-    // BrdReflect101
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return /*::abs*/(last_col - ::abs(last_col - x) + (x > last_col)) /*% (last_col + 1)*/;
+    }
 
-    template <typename D> struct BrdRowReflect101
+    __device__ __forceinline__ int idx_col(int x) const
     {
-        typedef D result_type;
+        return idx_col_low(idx_col_high(x));
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdRowReflect101(int width) : last_col(width - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdRowReflect101(int width, U) : last_col(width - 1) {}
+    template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
+    }
 
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return ::abs(x) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return ::abs(last_col - ::abs(last_col - x)) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_low(idx_col_high(x));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_low(x)]);
-        }
-
-        template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_high(x)]);
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col(x)]);
-        }
+    template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
+    {
+        return saturate_cast<D>(src(idx_row(y), idx_col(x)));
+    }
 
-        const int last_col;
-    };
+    const int last_row;
+    const int last_col;
+};
 
-    template <typename D> struct BrdColReflect101
+//////////////////////////////////////////////////////////////
+// BrdWrap
+
+template <typename D> struct BrdRowWrap
+{
+    typedef D result_type;
+
+    explicit __host__ __device__ __forceinline__ BrdRowWrap(int width_) : width(width_) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdRowWrap(int width_, U) : width(width_) {}
+
+    __device__ __forceinline__ int idx_col_low(int x) const
     {
-        typedef D result_type;
+        return (x >= 0) * x + (x < 0) * (x - ((x - width + 1) / width) * width);
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdColReflect101(int height) : last_row(height - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdColReflect101(int height, U) : last_row(height - 1) {}
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return (x < width) * x + (x >= width) * (x % width);
+    }
 
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return ::abs(y) % (last_row + 1);
-        }
-
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return ::abs(last_row - ::abs(last_row - y)) % (last_row + 1);
-        }
-
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_low(idx_row_high(y));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row_low(y) * step));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row_high(y) * step));
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
-        }
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_high(idx_col_low(x));
+    }
 
-        const int last_row;
-    };
+    template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col_low(x)]);
+    }
 
-    template <typename D> struct BrdReflect101
+    template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
     {
-        typedef D result_type;
+        return saturate_cast<D>(data[idx_col_high(x)]);
+    }
 
-        __host__ __device__ __forceinline__ BrdReflect101(int height, int width) : last_row(height - 1), last_col(width - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdReflect101(int height, int width, U) : last_row(height - 1), last_col(width - 1) {}
+    template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
+    {
+        return saturate_cast<D>(data[idx_col(x)]);
+    }
 
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return ::abs(y) % (last_row + 1);
-        }
+    const int width;
+};
 
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return ::abs(last_row - ::abs(last_row - y)) % (last_row + 1);
-        }
+template <typename D> struct BrdColWrap
+{
+    typedef D result_type;
 
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_low(idx_row_high(y));
-        }
+    explicit __host__ __device__ __forceinline__ BrdColWrap(int height_) : height(height_) {}
+    template <typename U> __host__ __device__ __forceinline__ BrdColWrap(int height_, U) : height(height_) {}
 
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return ::abs(x) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return ::abs(last_col - ::abs(last_col - x)) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_low(idx_col_high(x));
-        }
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return (y >= 0) * y + (y < 0) * (y - ((y - height + 1) / height) * height);
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
-        }
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return (y < height) * y + (y >= height) * (y % height);
+    }
 
-        template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
-        {
-            return saturate_cast<D>(src(idx_row(y), idx_col(x)));
-        }
+    __device__ __forceinline__ int idx_row(int y) const
+    {
+        return idx_row_high(idx_row_low(y));
+    }
 
-        const int last_row;
-        const int last_col;
-    };
+    template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row_low(y) * step));
+    }
 
-    //////////////////////////////////////////////////////////////
-    // BrdReflect
+    template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row_high(y) * step));
+    }
 
-    template <typename D> struct BrdRowReflect
+    template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
     {
-        typedef D result_type;
+        return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdRowReflect(int width) : last_col(width - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdRowReflect(int width, U) : last_col(width - 1) {}
+    const int height;
+};
 
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return (::abs(x) - (x < 0)) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return ::abs(last_col - ::abs(last_col - x) + (x > last_col)) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_low(idx_col_high(x));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_low(x)]);
-        }
-
-        template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_high(x)]);
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col(x)]);
-        }
+template <typename D> struct BrdWrap
+{
+    typedef D result_type;
 
-        const int last_col;
-    };
+    __host__ __device__ __forceinline__ BrdWrap(int height_, int width_) : 
+        height(height_), width(width_) 
+    {
+    }
+    template <typename U> 
+    __host__ __device__ __forceinline__ BrdWrap(int height_, int width_, U) : 
+        height(height_), width(width_) 
+    {
+    }
+
+    __device__ __forceinline__ int idx_row_low(int y) const
+    {
+        return (y >= 0) * y + (y < 0) * (y - ((y - height + 1) / height) * height);
+    }
+
+    __device__ __forceinline__ int idx_row_high(int y) const 
+    {
+        return (y < height) * y + (y >= height) * (y % height);
+    }
 
-    template <typename D> struct BrdColReflect
+    __device__ __forceinline__ int idx_row(int y) const
     {
-        typedef D result_type;
+        return idx_row_high(idx_row_low(y));
+    }
 
-        explicit __host__ __device__ __forceinline__ BrdColReflect(int height) : last_row(height - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdColReflect(int height, U) : last_row(height - 1) {}
+    __device__ __forceinline__ int idx_col_low(int x) const
+    {
+        return (x >= 0) * x + (x < 0) * (x - ((x - width + 1) / width) * width);
+    }
 
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return (::abs(y) - (y < 0)) % (last_row + 1);
-        }
-
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return ::abs(last_row - ::abs(last_row - y) + (y > last_row)) % (last_row + 1);
-        }
-
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_low(idx_row_high(y));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row_low(y) * step));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row_high(y) * step));
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
-        }
+    __device__ __forceinline__ int idx_col_high(int x) const 
+    {
+        return (x < width) * x + (x >= width) * (x % width);
+    }
+
+    __device__ __forceinline__ int idx_col(int x) const
+    {
+        return idx_col_high(idx_col_low(x));
+    }
 
-        const int last_row;
-    };
+    template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
+    {
+        return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
+    }
 
-    template <typename D> struct BrdReflect
+    template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
     {
-        typedef D result_type;
+        return saturate_cast<D>(src(idx_row(y), idx_col(x)));
+    }
+
+    const int height;
+    const int width;
+};
+
+//////////////////////////////////////////////////////////////
+// BorderReader
+
+template <typename Ptr2D, typename B> struct BorderReader
+{
+    typedef typename B::result_type elem_type;
+    typedef typename Ptr2D::index_type index_type;
 
-        __host__ __device__ __forceinline__ BrdReflect(int height, int width) : last_row(height - 1), last_col(width - 1) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdReflect(int height, int width, U) : last_row(height - 1), last_col(width - 1) {}
+    __host__ __device__ __forceinline__ BorderReader(const Ptr2D& ptr_, const B& b_) : ptr(ptr_), b(b_) {}
 
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return (::abs(y) - (y < 0)) % (last_row + 1);
-        }
+    __device__ __forceinline__ elem_type operator ()(index_type y, index_type x) const
+    {
+        return b.at(y, x, ptr);
+    }
 
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return /*::abs*/(last_row - ::abs(last_row - y) + (y > last_row)) /*% (last_row + 1)*/;
-        }
+    const Ptr2D ptr;
+    const B b;
+};
 
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_low(idx_row_high(y));
-        }
+// under win32 there is some bug with templated types that passed as kernel parameters
+// with this specialization all works fine
+template <typename Ptr2D, typename D> struct BorderReader< Ptr2D, BrdConstant<D> >
+{
+    typedef typename BrdConstant<D>::result_type elem_type;
+    typedef typename Ptr2D::index_type index_type;
 
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return (::abs(x) - (x < 0)) % (last_col + 1);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return /*::abs*/(last_col - ::abs(last_col - x) + (x > last_col)) /*% (last_col + 1)*/;
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_low(idx_col_high(x));
-        }
+    __host__ __device__ __forceinline__ BorderReader(const Ptr2D& src_, const BrdConstant<D>& b) : 
+        src(src_), height(b.height), width(b.width), val(b.val) 
+    {
+    }
+
+    __device__ __forceinline__ D operator ()(index_type y, index_type x) const
+    {
+        return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(src(y, x)) : val;
+    }
 
-        template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
-        }
+    const Ptr2D src;
+    const int height;
+    const int width;
+    const D val;
+};
 
-        template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
-        {
-            return saturate_cast<D>(src(idx_row(y), idx_col(x)));
-        }
-
-        const int last_row;
-        const int last_col;
-    };
-
-    //////////////////////////////////////////////////////////////
-    // BrdWrap
-
-    template <typename D> struct BrdRowWrap
-    {
-        typedef D result_type;
-
-        explicit __host__ __device__ __forceinline__ BrdRowWrap(int width_) : width(width_) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdRowWrap(int width_, U) : width(width_) {}
-
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return (x >= 0) * x + (x < 0) * (x - ((x - width + 1) / width) * width);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return (x < width) * x + (x >= width) * (x % width);
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_high(idx_col_low(x));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_low(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_low(x)]);
-        }
-
-        template <typename T> __device__ __forceinline__ D at_high(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col_high(x)]);
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int x, const T* data) const 
-        {
-            return saturate_cast<D>(data[idx_col(x)]);
-        }
-
-        const int width;
-    };
-
-    template <typename D> struct BrdColWrap
-    {
-        typedef D result_type;
-
-        explicit __host__ __device__ __forceinline__ BrdColWrap(int height_) : height(height_) {}
-        template <typename U> __host__ __device__ __forceinline__ BrdColWrap(int height_, U) : height(height_) {}
-
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return (y >= 0) * y + (y < 0) * (y - ((y - height + 1) / height) * height);
-        }
-
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return (y < height) * y + (y >= height) * (y % height);
-        }
-
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_high(idx_row_low(y));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_low(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row_low(y) * step));
-        }
-
-        template <typename T> __device__ __forceinline__ D at_high(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row_high(y) * step));
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int y, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
-        }
-
-        const int height;
-    };
-
-    template <typename D> struct BrdWrap
-    {
-        typedef D result_type;
-
-        __host__ __device__ __forceinline__ BrdWrap(int height_, int width_) : 
-            height(height_), width(width_) 
-        {
-        }
-        template <typename U> 
-        __host__ __device__ __forceinline__ BrdWrap(int height_, int width_, U) : 
-            height(height_), width(width_) 
-        {
-        }
-
-        __device__ __forceinline__ int idx_row_low(int y) const
-        {
-            return (y >= 0) * y + (y < 0) * (y - ((y - height + 1) / height) * height);
-        }
-
-        __device__ __forceinline__ int idx_row_high(int y) const 
-        {
-            return (y < height) * y + (y >= height) * (y % height);
-        }
-
-        __device__ __forceinline__ int idx_row(int y) const
-        {
-            return idx_row_high(idx_row_low(y));
-        }
-
-        __device__ __forceinline__ int idx_col_low(int x) const
-        {
-            return (x >= 0) * x + (x < 0) * (x - ((x - width + 1) / width) * width);
-        }
-
-        __device__ __forceinline__ int idx_col_high(int x) const 
-        {
-            return (x < width) * x + (x >= width) * (x % width);
-        }
-
-        __device__ __forceinline__ int idx_col(int x) const
-        {
-            return idx_col_high(idx_col_low(x));
-        }
-
-        template <typename T> __device__ __forceinline__ D at(int y, int x, const T* data, size_t step) const 
-        {
-            return saturate_cast<D>(((const T*)((const char*)data + idx_row(y) * step))[idx_col(x)]);
-        }
-
-        template <typename Ptr2D> __device__ __forceinline__ D at(typename Ptr2D::index_type y, typename Ptr2D::index_type x, const Ptr2D& src) const 
-        {
-            return saturate_cast<D>(src(idx_row(y), idx_col(x)));
-        }
-
-        const int height;
-        const int width;
-    };
-
-    //////////////////////////////////////////////////////////////
-    // BorderReader
-
-    template <typename Ptr2D, typename B> struct BorderReader
-    {
-        typedef typename B::result_type elem_type;
-        typedef typename Ptr2D::index_type index_type;
-
-        __host__ __device__ __forceinline__ BorderReader(const Ptr2D& ptr_, const B& b_) : ptr(ptr_), b(b_) {}
-
-        __device__ __forceinline__ elem_type operator ()(index_type y, index_type x) const
-        {
-            return b.at(y, x, ptr);
-        }
-
-        const Ptr2D ptr;
-        const B b;
-    };
-
-    // under win32 there is some bug with templated types that passed as kernel parameters
-    // with this specialization all works fine
-    template <typename Ptr2D, typename D> struct BorderReader< Ptr2D, BrdConstant<D> >
-    {
-        typedef typename BrdConstant<D>::result_type elem_type;
-        typedef typename Ptr2D::index_type index_type;
-
-        __host__ __device__ __forceinline__ BorderReader(const Ptr2D& src_, const BrdConstant<D>& b) : 
-            src(src_), height(b.height), width(b.width), val(b.val) 
-        {
-        }
-
-        __device__ __forceinline__ D operator ()(index_type y, index_type x) const
-        {
-            return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(src(y, x)) : val;
-        }
-
-        const Ptr2D src;
-        const int height;
-        const int width;
-        const D val;
-    };
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/color.hpp b/modules/gpu/src/opencv2/gpu/device/color.hpp
index f6bdde92f714e9d9002037998a96d4eb28fd8521..16b108a5b9ce8a63d17f123e6178cc3ea289d009 100644
--- a/modules/gpu/src/opencv2/gpu/device/color.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/color.hpp
@@ -43,179 +43,181 @@
 #ifndef __OPENCV_GPU_COLOR_HPP__
 #define __OPENCV_GPU_COLOR_HPP__
 
+#include "internal_shared.hpp"
 #include "detail/color_detail.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    // All OPENCV_GPU_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements
-    // template <typename T> class ColorSpace1_to_ColorSpace2_traits
-    // {
-    //     typedef ... functor_type;
-    //     static __host__ __device__ functor_type create_functor();
-    // };
-
-    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgb, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_bgra, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgba, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_bgr, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgb, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgba, 4, 4, 2)
-    
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+// All OPENCV_GPU_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements
+// template <typename T> class ColorSpace1_to_ColorSpace2_traits
+// {
+//     typedef ... functor_type;
+//     static __host__ __device__ functor_type create_functor();
+// };
+
+OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgb, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_bgra, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgba, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_bgr, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgb, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgba, 4, 4, 2)
+
 #undef OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr555, 3, 0, 5)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr565, 3, 0, 6)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr555, 3, 2, 5)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr565, 3, 2, 6)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr555, 4, 0, 5)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr565, 4, 0, 6)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr555, 4, 2, 5)
-    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr565, 4, 2, 6)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr555, 3, 0, 5)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr565, 3, 0, 6)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr555, 3, 2, 5)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr565, 3, 2, 6)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr555, 4, 0, 5)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr565, 4, 0, 6)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr555, 4, 2, 5)
+OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr565, 4, 2, 6)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgb, 3, 2, 5)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgb, 3, 2, 6)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgr, 3, 0, 5)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgr, 3, 0, 6)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgba, 4, 2, 5)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgba, 4, 2, 6)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgra, 4, 0, 5)
-    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgra, 4, 0, 6)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgb, 3, 2, 5)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgb, 3, 2, 6)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgr, 3, 0, 5)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgr, 3, 0, 6)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgba, 4, 2, 5)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgba, 4, 2, 6)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgra, 4, 0, 5)
+OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgra, 4, 0, 6)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgr, 3)
-    OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgra, 4)
-    
+OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgr, 3)
+OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgra, 4)
+
 #undef OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr555, 5)
-    OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr565, 6)
+OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr555, 5)
+OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr565, 6)
 
 #undef OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr555_to_gray, 5)
-    OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr565_to_gray, 6)
+OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr555_to_gray, 5)
+OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr565_to_gray, 6)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgb_to_gray, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgr_to_gray, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgba_to_gray, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgra_to_gray, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgb_to_gray, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgr_to_gray, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgba_to_gray, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgra_to_gray, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv4, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv4, 4, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv4, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv4, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv4, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv4, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv4, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv4, 4, 4, 2)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgb, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgba, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgb, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgba, 4, 4, 0)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgr, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgra, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgr, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgra, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgb, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgba, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgb, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgba, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgr, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgra, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgr, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgra, 4, 4, 2)
 
 #undef OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb4, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb4, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb4, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb4, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb4, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb4, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb4, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb4, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgb, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgba, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgb, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgba, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgr, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgra, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgr, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgra, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgb, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgba, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgb, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgba, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgr, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgra, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgr, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgra, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz4, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz4, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz4, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz4, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz4, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz4, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz4, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz4, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgb, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgb, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgba, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgba, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgr, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgr, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgra, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgra, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgb, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgb, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgba, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgba, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgr, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgr, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgra, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgra, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv4, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv4, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv4, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv4, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv4, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv4, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv4, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv4, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgb, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgba, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgb, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgba, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgr, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgra, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgr, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgra, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgb, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgba, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgb, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgba, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgr, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgra, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgr, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgra, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls4, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls4, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls4, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls4, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls4, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls4, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls4, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls4, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS
 
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgb, 3, 3, 2)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgba, 3, 4, 2)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgb, 4, 3, 2)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgba, 4, 4, 2)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgr, 3, 3, 0)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgra, 3, 4, 0)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgr, 4, 3, 0)
-    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgra, 4, 4, 0)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgb, 3, 3, 2)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgba, 3, 4, 2)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgb, 4, 3, 2)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgba, 4, 4, 2)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgr, 3, 3, 0)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgra, 3, 4, 0)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgr, 4, 3, 0)
+OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgra, 4, 4, 0)
 
 #undef OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS
-}}}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp b/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp
index c8937c1d90da8f09a5f3e1097eb73c1189828cfb..e29f003241563eac2637ce4771de81b7c600b9ef 100644
--- a/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp
@@ -45,6 +45,8 @@
 
 #include "internal_shared.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
 #if defined(_WIN64) || defined(__LP64__)		
     // 64-bit register modifier for inlined asm
     #define OPENCV_GPU_ASM_PTR "l"
@@ -53,8 +55,6 @@
     #define OPENCV_GPU_ASM_PTR "r"
 #endif
 
-namespace cv { namespace gpu { namespace device
-{
     #if __CUDA_ARCH__ >= 200
 
         // for Fermi memory space is detected automatically
@@ -99,6 +99,7 @@ namespace cv { namespace gpu { namespace device
     #undef OPENCV_GPU_DEFINE_FORCE_GLOB_B
         
     #endif // __CUDA_ARCH__ >= 200
-}}}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_DATAMOV_UTILS_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/color_detail.hpp b/modules/gpu/src/opencv2/gpu/device/detail/color_detail.hpp
index ad5e815517803a88640ed24054f990333d7fe08a..6ccc45c05a2c2f819f1c5c607162b7f081abbc4b 100644
--- a/modules/gpu/src/opencv2/gpu/device/detail/color_detail.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/detail/color_detail.hpp
@@ -43,93 +43,94 @@
 #ifndef __OPENCV_GPU_COLOR_DETAIL_HPP__
 #define __OPENCV_GPU_COLOR_DETAIL_HPP__
 
+#include "internal_shared.hpp"
 #include "../vec_traits.hpp"
 #include "../saturate_cast.hpp"
 #include "../limits.hpp"
 #include "../functional.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
 #ifndef CV_DESCALE
     #define CV_DESCALE(x, n) (((x) + (1 << ((n)-1))) >> (n))
 #endif
 
-namespace cv { namespace gpu { namespace device
+namespace detail
 {
-    namespace detail
+    template<typename T> struct ColorChannel
     {
-        template<typename T> struct ColorChannel
-        {
-            typedef float worktype_f;
-            static __device__ __forceinline__ T max() { return numeric_limits<T>::max(); }
-            static __device__ __forceinline__ T half() { return (T)(max()/2 + 1); }
-        };
-        template<> struct ColorChannel<float>
-        {
-            typedef float worktype_f;
-            static __device__ __forceinline__ float max() { return 1.f; }
-            static __device__ __forceinline__ float half() { return 0.5f; }
-        };
-
-        template <typename T> static __device__ __forceinline__ void setAlpha(typename TypeVec<T, 3>::vec_type& vec, T val)
-        {
-        }
-        template <typename T> static __device__ __forceinline__ void setAlpha(typename TypeVec<T, 4>::vec_type& vec, T val)
-        {
-            vec.w = val;
-        }
-        template <typename T> static __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 3>::vec_type& vec)
-        {
-            return ColorChannel<T>::max();
-        }
-        template <typename T> static __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 4>::vec_type& vec)
-        {
-            return vec.w;
-        }
+        typedef float worktype_f;
+        static __device__ __forceinline__ T max() { return numeric_limits<T>::max(); }
+        static __device__ __forceinline__ T half() { return (T)(max()/2 + 1); }
+    };
+    template<> struct ColorChannel<float>
+    {
+        typedef float worktype_f;
+        static __device__ __forceinline__ float max() { return 1.f; }
+        static __device__ __forceinline__ float half() { return 0.5f; }
+    };
 
-        enum
-        {
-            yuv_shift  = 14,
-            xyz_shift  = 12,
-            R2Y        = 4899,
-            G2Y        = 9617,
-            B2Y        = 1868,
-            BLOCK_SIZE = 256
-        };
+    template <typename T> static __device__ __forceinline__ void setAlpha(typename TypeVec<T, 3>::vec_type& vec, T val)
+    {
+    }
+    template <typename T> static __device__ __forceinline__ void setAlpha(typename TypeVec<T, 4>::vec_type& vec, T val)
+    {
+        vec.w = val;
+    }
+    template <typename T> static __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 3>::vec_type& vec)
+    {
+        return ColorChannel<T>::max();
+    }
+    template <typename T> static __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 4>::vec_type& vec)
+    {
+        return vec.w;
     }
 
+    enum
+    {
+        yuv_shift  = 14,
+        xyz_shift  = 12,
+        R2Y        = 4899,
+        G2Y        = 9617,
+        B2Y        = 1868,
+        BLOCK_SIZE = 256
+    };
+}
+
 ////////////////// Various 3/4-channel to 3/4-channel RGB transformations /////////////////
 
-    namespace detail
+namespace detail
+{
+    template <typename T, int scn, int dcn, int bidx> struct RGB2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
     {
-        template <typename T, int scn, int dcn, int bidx> struct RGB2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+        __device__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                dst.x = (&src.x)[bidx];
-                dst.y = src.y;
-                dst.z = (&src.x)[bidx^2];
-                setAlpha(dst, getAlpha<T>(src));
+            dst.x = (&src.x)[bidx];
+            dst.y = src.y;
+            dst.z = (&src.x)[bidx^2];
+            setAlpha(dst, getAlpha<T>(src));
 
-                return dst;
-            }
-        };
+            return dst;
+        }
+    };
 
-        template <> struct RGB2RGB<uchar, 4, 4, 2> : unary_function<uint, uint>
+    template <> struct RGB2RGB<uchar, 4, 4, 2> : unary_function<uint, uint>
+    {
+        __device__ uint operator()(uint src) const
         {
-            __device__ uint operator()(uint src) const
-            {
-                uint dst = 0;
-
-                dst |= (0xffu & (src >> 16));
-                dst |= (0xffu & (src >> 8)) << 8;
-                dst |= (0xffu & (src)) << 16;
-                dst |= (0xffu & (src >> 24)) << 24;
-
-                return dst;
-            }
-        };
-    }
+            uint dst = 0;
+
+            dst |= (0xffu & (src >> 16));
+            dst |= (0xffu & (src >> 8)) << 8;
+            dst |= (0xffu & (src)) << 16;
+            dst |= (0xffu & (src >> 24)) << 24;
+
+            return dst;
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -143,55 +144,55 @@ namespace cv { namespace gpu { namespace device
 
 /////////// Transforming 16-bit (565 or 555) RGB to/from 24/32-bit (888[8]) RGB //////////
 
-    namespace detail
+namespace detail
+{
+    template <int green_bits, int bidx> struct RGB2RGB5x5Converter;
+    template<int bidx> struct RGB2RGB5x5Converter<6, bidx> 
+    {
+        static __device__ __forceinline__ ushort cvt(const uchar3& src)
+        {
+            return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~3) << 3) | (((&src.x)[bidx^2] & ~7) << 8));
+        }
+        static __device__ __forceinline__ ushort cvt(uint src)
+        {
+            uint b = 0xffu & (src >> (bidx * 8));
+            uint g = 0xffu & (src >> 8);
+            uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
+            return (ushort)((b >> 3) | ((g & ~3) << 3) | ((r & ~7) << 8));
+        }
+    };
+    template<int bidx> struct RGB2RGB5x5Converter<5, bidx> 
     {
-        template <int green_bits, int bidx> struct RGB2RGB5x5Converter;
-        template<int bidx> struct RGB2RGB5x5Converter<6, bidx> 
+        static __device__ __forceinline__ ushort cvt(const uchar3& src)
         {
-            static __device__ __forceinline__ ushort cvt(const uchar3& src)
-            {
-                return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~3) << 3) | (((&src.x)[bidx^2] & ~7) << 8));
-            }
-            static __device__ __forceinline__ ushort cvt(uint src)
-            {
-                uint b = 0xffu & (src >> (bidx * 8));
-                uint g = 0xffu & (src >> 8);
-                uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
-                return (ushort)((b >> 3) | ((g & ~3) << 3) | ((r & ~7) << 8));
-            }
-        };
-        template<int bidx> struct RGB2RGB5x5Converter<5, bidx> 
+            return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~7) << 2) | (((&src.x)[bidx^2] & ~7) << 7));
+        }
+        static __device__ __forceinline__ ushort cvt(uint src)
         {
-            static __device__ __forceinline__ ushort cvt(const uchar3& src)
-            {
-                return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~7) << 2) | (((&src.x)[bidx^2] & ~7) << 7));
-            }
-            static __device__ __forceinline__ ushort cvt(uint src)
-            {
-                uint b = 0xffu & (src >> (bidx * 8));
-                uint g = 0xffu & (src >> 8);
-                uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
-                uint a = 0xffu & (src >> 24);
-                return (ushort)((b >> 3) | ((g & ~7) << 2) | ((r & ~7) << 7) | (a * 0x8000));
-            }
-        };
-
-        template<int scn, int bidx, int green_bits> struct RGB2RGB5x5;
-        template<int bidx, int green_bits> struct RGB2RGB5x5<3, bidx,green_bits> : unary_function<uchar3, ushort>
+            uint b = 0xffu & (src >> (bidx * 8));
+            uint g = 0xffu & (src >> 8);
+            uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
+            uint a = 0xffu & (src >> 24);
+            return (ushort)((b >> 3) | ((g & ~7) << 2) | ((r & ~7) << 7) | (a * 0x8000));
+        }
+    };
+
+    template<int scn, int bidx, int green_bits> struct RGB2RGB5x5;
+    template<int bidx, int green_bits> struct RGB2RGB5x5<3, bidx,green_bits> : unary_function<uchar3, ushort>
+    {
+        __device__ __forceinline__ ushort operator()(const uchar3& src) const
         {
-            __device__ __forceinline__ ushort operator()(const uchar3& src) const
-            {
-                return RGB2RGB5x5Converter<green_bits, bidx>::cvt(src);
-            }
-        };
-        template<int bidx, int green_bits> struct RGB2RGB5x5<4, bidx,green_bits> : unary_function<uint, ushort>
+            return RGB2RGB5x5Converter<green_bits, bidx>::cvt(src);
+        }
+    };
+    template<int bidx, int green_bits> struct RGB2RGB5x5<4, bidx,green_bits> : unary_function<uint, ushort>
+    {
+        __device__ __forceinline__ ushort operator()(uint src) const
         {
-            __device__ __forceinline__ ushort operator()(uint src) const
-            {
-                return RGB2RGB5x5Converter<green_bits, bidx>::cvt(src);
-            }
-        };
-    }
+            return RGB2RGB5x5Converter<green_bits, bidx>::cvt(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(name, scn, bidx, green_bits) \
     struct name ## _traits \
@@ -203,65 +204,65 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
+namespace detail
+{
+    template <int green_bits, int bidx> struct RGB5x52RGBConverter;    
+    template <int bidx> struct RGB5x52RGBConverter<5, bidx>
     {
-        template <int green_bits, int bidx> struct RGB5x52RGBConverter;    
-        template <int bidx> struct RGB5x52RGBConverter<5, bidx>
-        {
-            static __device__ __forceinline__ void cvt(uint src, uchar3& dst)
-            {            
-                (&dst.x)[bidx] = src << 3;
-                dst.y = (src >> 2) & ~7;
-                (&dst.x)[bidx ^ 2] = (src >> 7) & ~7;
-            }
-            static __device__ __forceinline__ void cvt(uint src, uint& dst)
-            {   
-                dst = 0;
-
-                dst |= (0xffu & (src << 3)) << (bidx * 8);
-                dst |= (0xffu & ((src >> 2) & ~7)) << 8;
-                dst |= (0xffu & ((src >> 7) & ~7)) << ((bidx ^ 2) * 8);
-                dst |= ((src & 0x8000) * 0xffu) << 24;
-            }
-        };
-        template <int bidx> struct RGB5x52RGBConverter<6, bidx>
-        {
-            static __device__ __forceinline__ void cvt(uint src, uchar3& dst)
-            {            
-                (&dst.x)[bidx] = src << 3;
-                dst.y = (src >> 3) & ~3;
-                (&dst.x)[bidx ^ 2] = (src >> 8) & ~7;
-            }
-            static __device__ __forceinline__ void cvt(uint src, uint& dst)
-            {           
-                dst = 0xffu << 24;
-
-                dst |= (0xffu & (src << 3)) << (bidx * 8);
-                dst |= (0xffu &((src >> 3) & ~3)) << 8;
-                dst |= (0xffu & ((src >> 8) & ~7)) << ((bidx ^ 2) * 8);
-            }
-        };
-
-        template <int dcn, int bidx, int green_bits> struct RGB5x52RGB;
-        template <int bidx, int green_bits> struct RGB5x52RGB<3, bidx, green_bits> : unary_function<ushort, uchar3>
+        static __device__ __forceinline__ void cvt(uint src, uchar3& dst)
+        {            
+            (&dst.x)[bidx] = src << 3;
+            dst.y = (src >> 2) & ~7;
+            (&dst.x)[bidx ^ 2] = (src >> 7) & ~7;
+        }
+        static __device__ __forceinline__ void cvt(uint src, uint& dst)
+        {   
+            dst = 0;
+
+            dst |= (0xffu & (src << 3)) << (bidx * 8);
+            dst |= (0xffu & ((src >> 2) & ~7)) << 8;
+            dst |= (0xffu & ((src >> 7) & ~7)) << ((bidx ^ 2) * 8);
+            dst |= ((src & 0x8000) * 0xffu) << 24;
+        }
+    };
+    template <int bidx> struct RGB5x52RGBConverter<6, bidx>
+    {
+        static __device__ __forceinline__ void cvt(uint src, uchar3& dst)
+        {            
+            (&dst.x)[bidx] = src << 3;
+            dst.y = (src >> 3) & ~3;
+            (&dst.x)[bidx ^ 2] = (src >> 8) & ~7;
+        }
+        static __device__ __forceinline__ void cvt(uint src, uint& dst)
+        {           
+            dst = 0xffu << 24;
+
+            dst |= (0xffu & (src << 3)) << (bidx * 8);
+            dst |= (0xffu &((src >> 3) & ~3)) << 8;
+            dst |= (0xffu & ((src >> 8) & ~7)) << ((bidx ^ 2) * 8);
+        }
+    };
+
+    template <int dcn, int bidx, int green_bits> struct RGB5x52RGB;
+    template <int bidx, int green_bits> struct RGB5x52RGB<3, bidx, green_bits> : unary_function<ushort, uchar3>
+    {
+        __device__ __forceinline__ uchar3 operator()(ushort src) const
         {
-            __device__ __forceinline__ uchar3 operator()(ushort src) const
-            {
-                uchar3 dst;
-                RGB5x52RGBConverter<green_bits, bidx>::cvt(src, dst);
-                return dst;
-            }
-        };
-        template <int bidx, int green_bits> struct RGB5x52RGB<4, bidx, green_bits> : unary_function<ushort, uint>
+            uchar3 dst;
+            RGB5x52RGBConverter<green_bits, bidx>::cvt(src, dst);
+            return dst;
+        }
+    };
+    template <int bidx, int green_bits> struct RGB5x52RGB<4, bidx, green_bits> : unary_function<ushort, uint>
+    {
+        __device__ __forceinline__ uint operator()(ushort src) const
         {
-            __device__ __forceinline__ uint operator()(ushort src) const
-            {
-                uint dst;
-                RGB5x52RGBConverter<green_bits, bidx>::cvt(src, dst);
-                return dst;
-            }
-        };
-    }
+            uint dst;
+            RGB5x52RGBConverter<green_bits, bidx>::cvt(src, dst);
+            return dst;
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(name, dcn, bidx, green_bits) \
     struct name ## _traits \
@@ -275,34 +276,34 @@ namespace cv { namespace gpu { namespace device
 
 ///////////////////////////////// Grayscale to Color ////////////////////////////////
 
-    namespace detail
+namespace detail
+{
+    template <typename T, int dcn> struct Gray2RGB : unary_function<T, typename TypeVec<T, dcn>::vec_type>
     {
-        template <typename T, int dcn> struct Gray2RGB : unary_function<T, typename TypeVec<T, dcn>::vec_type>
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(T src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(T src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                dst.z = dst.y = dst.x = src;            
-                setAlpha(dst, ColorChannel<T>::max());
+            dst.z = dst.y = dst.x = src;            
+            setAlpha(dst, ColorChannel<T>::max());
 
-                return dst;
-            }
-        };
-        template <> struct Gray2RGB<uchar, 4> : unary_function<uchar, uint>
+            return dst;
+        }
+    };
+    template <> struct Gray2RGB<uchar, 4> : unary_function<uchar, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                uint dst = 0xffu << 24;
+            uint dst = 0xffu << 24;
 
-                dst |= src;
-                dst |= src << 8;
-                dst |= src << 16;
+            dst |= src;
+            dst |= src << 8;
+            dst |= src << 16;
 
-                return dst;
-            }
-        };
-    }
+            return dst;
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(name, dcn) \
     template <typename T> struct name ## _traits \
@@ -314,33 +315,33 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
+namespace detail
+{
+    template <int green_bits> struct Gray2RGB5x5Converter;
+    template<> struct Gray2RGB5x5Converter<6> 
     {
-        template <int green_bits> struct Gray2RGB5x5Converter;
-        template<> struct Gray2RGB5x5Converter<6> 
+        static __device__ __forceinline__ ushort cvt(uint t)
         {
-            static __device__ __forceinline__ ushort cvt(uint t)
-            {
-                return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
-            }
-        };
-        template<> struct Gray2RGB5x5Converter<5> 
+            return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
+        }
+    };
+    template<> struct Gray2RGB5x5Converter<5> 
+    {
+        static __device__ __forceinline__ ushort cvt(uint t)
         {
-            static __device__ __forceinline__ ushort cvt(uint t)
-            {
-                t >>= 3;
-                return (ushort)(t | (t << 5) | (t << 10));
-            }
-        };
-
-        template<int green_bits> struct Gray2RGB5x5 : unary_function<uchar, ushort>
+            t >>= 3;
+            return (ushort)(t | (t << 5) | (t << 10));
+        }
+    };
+
+    template<int green_bits> struct Gray2RGB5x5 : unary_function<uchar, ushort>
+    {
+        __device__ __forceinline__ ushort operator()(uint src) const
         {
-            __device__ __forceinline__ ushort operator()(uint src) const
-            {
-                return Gray2RGB5x5Converter<green_bits>::cvt(src);
-            }
-        };
-    }
+            return Gray2RGB5x5Converter<green_bits>::cvt(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(name, green_bits) \
     struct name ## _traits \
@@ -354,32 +355,32 @@ namespace cv { namespace gpu { namespace device
 
 ///////////////////////////////// Color to Grayscale ////////////////////////////////
 
-    namespace detail
+namespace detail
+{
+    template <int green_bits> struct RGB5x52GrayConverter;
+    template <> struct RGB5x52GrayConverter<6> 
     {
-        template <int green_bits> struct RGB5x52GrayConverter;
-        template <> struct RGB5x52GrayConverter<6> 
+        static __device__ __forceinline__ uchar cvt(uint t)
         {
-            static __device__ __forceinline__ uchar cvt(uint t)
-            {
-                return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 3) & 0xfc) * G2Y + ((t >> 8) & 0xf8) * R2Y, yuv_shift);
-            }
-        };
-        template <> struct RGB5x52GrayConverter<5> 
+            return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 3) & 0xfc) * G2Y + ((t >> 8) & 0xf8) * R2Y, yuv_shift);
+        }
+    };
+    template <> struct RGB5x52GrayConverter<5> 
+    {
+        static __device__ __forceinline__ uchar cvt(uint t)
         {
-            static __device__ __forceinline__ uchar cvt(uint t)
-            {
-                return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 2) & 0xf8) * G2Y + ((t >> 7) & 0xf8) * R2Y, yuv_shift);
-            }
-        };   
+            return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 2) & 0xf8) * G2Y + ((t >> 7) & 0xf8) * R2Y, yuv_shift);
+        }
+    };   
 
-        template<int green_bits> struct RGB5x52Gray : unary_function<ushort, uchar>
+    template<int green_bits> struct RGB5x52Gray : unary_function<ushort, uchar>
+    {
+        __device__ __forceinline__ uchar operator()(uint src) const
         {
-            __device__ __forceinline__ uchar operator()(uint src) const
-            {
-                return RGB5x52GrayConverter<green_bits>::cvt(src);
-            }
-        };
-    }
+            return RGB5x52GrayConverter<green_bits>::cvt(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(name, green_bits) \
     struct name ## _traits \
@@ -391,39 +392,39 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
+namespace detail
+{
+    template <int bidx, typename T> static __device__ __forceinline__ T RGB2GrayConvert(const T* src)
     {
-        template <int bidx, typename T> static __device__ __forceinline__ T RGB2GrayConvert(const T* src)
-        {
-            return (T)CV_DESCALE((unsigned)(src[bidx] * B2Y + src[1] * G2Y + src[bidx^2] * R2Y), yuv_shift);
-        }
-        template <int bidx> static __device__ __forceinline__ uchar RGB2GrayConvert(uint src)
+        return (T)CV_DESCALE((unsigned)(src[bidx] * B2Y + src[1] * G2Y + src[bidx^2] * R2Y), yuv_shift);
+    }
+    template <int bidx> static __device__ __forceinline__ uchar RGB2GrayConvert(uint src)
+    {
+        uint b = 0xffu & (src >> (bidx * 8));
+        uint g = 0xffu & (src >> 8);
+        uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
+        return CV_DESCALE((uint)(b * B2Y + g * G2Y + r * R2Y), yuv_shift);
+    }
+    template <int bidx> static __device__ __forceinline__ float RGB2GrayConvert(const float* src)
+    {
+        return src[bidx] * 0.114f + src[1] * 0.587f + src[bidx^2] * 0.299f;
+    }
+
+    template <typename T, int scn, int bidx> struct RGB2Gray : unary_function<typename TypeVec<T, scn>::vec_type, T>
+    {
+        __device__ __forceinline__ T operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            uint b = 0xffu & (src >> (bidx * 8));
-            uint g = 0xffu & (src >> 8);
-            uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
-            return CV_DESCALE((uint)(b * B2Y + g * G2Y + r * R2Y), yuv_shift);
+            return RGB2GrayConvert<bidx>(&src.x);
         }
-        template <int bidx> static __device__ __forceinline__ float RGB2GrayConvert(const float* src)
+    };
+    template <int bidx> struct RGB2Gray<uchar, 4, bidx> : unary_function<uint, uchar>
+    {
+        __device__ __forceinline__ uchar operator()(uint src) const
         {
-            return src[bidx] * 0.114f + src[1] * 0.587f + src[bidx^2] * 0.299f;
+            return RGB2GrayConvert<bidx>(src);
         }
-
-        template <typename T, int scn, int bidx> struct RGB2Gray : unary_function<typename TypeVec<T, scn>::vec_type, T>
-        {
-            __device__ __forceinline__ T operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                return RGB2GrayConvert<bidx>(&src.x);
-            }
-        };
-        template <int bidx> struct RGB2Gray<uchar, 4, bidx> : unary_function<uint, uchar>
-        {
-            __device__ __forceinline__ uchar operator()(uint src) const
-            {
-                return RGB2GrayConvert<bidx>(src);
-            }
-        };
-    }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(name, scn, bidx) \
     template <typename T> struct name ## _traits \
@@ -437,63 +438,63 @@ namespace cv { namespace gpu { namespace device
 
 ///////////////////////////////////// RGB <-> YUV //////////////////////////////////////
 
-    namespace detail
+namespace detail
+{
+    __constant__ float c_RGB2YUVCoeffs_f[5] = { 0.114f, 0.587f, 0.299f, 0.492f, 0.877f };
+    __constant__ int   c_RGB2YUVCoeffs_i[5] = { B2Y, G2Y, R2Y, 8061, 14369 };
+
+    template <int bidx, typename T, typename D> static __device__ void RGB2YUVConvert(const T* src, D& dst)
     {
-        __constant__ float c_RGB2YUVCoeffs_f[5] = { 0.114f, 0.587f, 0.299f, 0.492f, 0.877f };
-        __constant__ int   c_RGB2YUVCoeffs_i[5] = { B2Y, G2Y, R2Y, 8061, 14369 };
+        const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
 
-        template <int bidx, typename T, typename D> static __device__ void RGB2YUVConvert(const T* src, D& dst)
-        {
-            const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
+        const int Y = CV_DESCALE(src[0] * c_RGB2YUVCoeffs_i[bidx^2] + src[1] * c_RGB2YUVCoeffs_i[1] + src[2] * c_RGB2YUVCoeffs_i[bidx], yuv_shift);
+        const int Cr = CV_DESCALE((src[bidx^2] - Y) * c_RGB2YUVCoeffs_i[3] + delta, yuv_shift);
+        const int Cb = CV_DESCALE((src[bidx] - Y) * c_RGB2YUVCoeffs_i[4] + delta, yuv_shift);
 
-            const int Y = CV_DESCALE(src[0] * c_RGB2YUVCoeffs_i[bidx^2] + src[1] * c_RGB2YUVCoeffs_i[1] + src[2] * c_RGB2YUVCoeffs_i[bidx], yuv_shift);
-            const int Cr = CV_DESCALE((src[bidx^2] - Y) * c_RGB2YUVCoeffs_i[3] + delta, yuv_shift);
-            const int Cb = CV_DESCALE((src[bidx] - Y) * c_RGB2YUVCoeffs_i[4] + delta, yuv_shift);
+        dst.x = saturate_cast<T>(Y);
+        dst.y = saturate_cast<T>(Cr);
+        dst.z = saturate_cast<T>(Cb);
+    }
+    template <int bidx> static __device__ uint RGB2YUVConvert(uint src)
+    {
+        const uint delta = ColorChannel<uchar>::half() * (1 << yuv_shift);
 
-            dst.x = saturate_cast<T>(Y);
-            dst.y = saturate_cast<T>(Cr);
-            dst.z = saturate_cast<T>(Cb);
-        }
-        template <int bidx> static __device__ uint RGB2YUVConvert(uint src)
-        {
-            const uint delta = ColorChannel<uchar>::half() * (1 << yuv_shift);
+        const uint Y = CV_DESCALE((0xffu & src) * c_RGB2YUVCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YUVCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YUVCoeffs_i[bidx], yuv_shift);
+        const uint Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YUVCoeffs_i[3] + delta, yuv_shift);
+        const uint Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YUVCoeffs_i[4] + delta, yuv_shift);
 
-            const uint Y = CV_DESCALE((0xffu & src) * c_RGB2YUVCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YUVCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YUVCoeffs_i[bidx], yuv_shift);
-            const uint Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YUVCoeffs_i[3] + delta, yuv_shift);
-            const uint Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YUVCoeffs_i[4] + delta, yuv_shift);
+        uint dst = 0;
 
-            uint dst = 0;
+        dst |= saturate_cast<uchar>(Y);
+        dst |= saturate_cast<uchar>(Cr) << 8;
+        dst |= saturate_cast<uchar>(Cb) << 16;
 
-            dst |= saturate_cast<uchar>(Y);
-            dst |= saturate_cast<uchar>(Cr) << 8;
-            dst |= saturate_cast<uchar>(Cb) << 16;
+        return dst;
+    }
+    template <int bidx, typename D> static __device__ __forceinline__ void RGB2YUVConvert(const float* src, D& dst)
+    {
+        dst.x = src[0] * c_RGB2YUVCoeffs_f[bidx^2] + src[1] * c_RGB2YUVCoeffs_f[1] + src[2] * c_RGB2YUVCoeffs_f[bidx];
+        dst.y = (src[bidx^2] - dst.x) * c_RGB2YUVCoeffs_f[3] + ColorChannel<float>::half();
+        dst.z = (src[bidx] - dst.x) * c_RGB2YUVCoeffs_f[4] + ColorChannel<float>::half();
+    }
 
+    template <typename T, int scn, int dcn, int bidx> struct RGB2YUV : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
+        {
+            typename TypeVec<T, dcn>::vec_type dst;
+            RGB2YUVConvert<bidx>(&src.x, dst);
             return dst;
         }
-        template <int bidx, typename D> static __device__ __forceinline__ void RGB2YUVConvert(const float* src, D& dst)
+    };
+    template <int bidx> struct RGB2YUV<uchar, 4, 4, bidx> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint src) const
         {
-            dst.x = src[0] * c_RGB2YUVCoeffs_f[bidx^2] + src[1] * c_RGB2YUVCoeffs_f[1] + src[2] * c_RGB2YUVCoeffs_f[bidx];
-            dst.y = (src[bidx^2] - dst.x) * c_RGB2YUVCoeffs_f[3] + ColorChannel<float>::half();
-            dst.z = (src[bidx] - dst.x) * c_RGB2YUVCoeffs_f[4] + ColorChannel<float>::half();
+            return RGB2YUVConvert<bidx>(src);
         }
-
-        template <typename T, int scn, int dcn, int bidx> struct RGB2YUV : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
-        {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
-                RGB2YUVConvert<bidx>(&src.x, dst);
-                return dst;
-            }
-        };
-        template <int bidx> struct RGB2YUV<uchar, 4, 4, bidx> : unary_function<uint, uint>
-        {
-            __device__ __forceinline__ uint operator ()(uint src) const
-            {
-                return RGB2YUVConvert<bidx>(src);
-            }
-        };
-    }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -505,66 +506,66 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
-    {
-        __constant__ float c_YUV2RGBCoeffs_f[5] = { 2.032f, -0.395f, -0.581f, 1.140f };
-        __constant__ int   c_YUV2RGBCoeffs_i[5] = { 33292, -6472, -9519, 18678 }; 
+namespace detail
+{
+    __constant__ float c_YUV2RGBCoeffs_f[5] = { 2.032f, -0.395f, -0.581f, 1.140f };
+    __constant__ int   c_YUV2RGBCoeffs_i[5] = { 33292, -6472, -9519, 18678 }; 
 
-        template <int bidx, typename T, typename D> static __device__ void YUV2RGBConvert(const T& src, D* dst)
-        {
-            const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
-            const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
-            const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
+    template <int bidx, typename T, typename D> static __device__ void YUV2RGBConvert(const T& src, D* dst)
+    {
+        const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
+        const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
+        const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
 
-            dst[bidx] = saturate_cast<D>(b);
-            dst[1] = saturate_cast<D>(g);
-            dst[bidx^2] = saturate_cast<D>(r);
-        }
-        template <int bidx> static __device__ uint YUV2RGBConvert(uint src)
-        {
-            const int x = 0xff & (src);
-            const int y = 0xff & (src >> 8);
-            const int z = 0xff & (src >> 16);
-            
-            const uint b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
-            const uint g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
-            const uint r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
+        dst[bidx] = saturate_cast<D>(b);
+        dst[1] = saturate_cast<D>(g);
+        dst[bidx^2] = saturate_cast<D>(r);
+    }
+    template <int bidx> static __device__ uint YUV2RGBConvert(uint src)
+    {
+        const int x = 0xff & (src);
+        const int y = 0xff & (src >> 8);
+        const int z = 0xff & (src >> 16);
+        
+        const uint b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
+        const uint g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
+        const uint r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
 
-            uint dst = 0xffu << 24;
+        uint dst = 0xffu << 24;
 
-            dst |= saturate_cast<uchar>(b) << (bidx * 8);
-            dst |= saturate_cast<uchar>(g) << 8;
-            dst |= saturate_cast<uchar>(r) << ((bidx ^ 2) * 8);
+        dst |= saturate_cast<uchar>(b) << (bidx * 8);
+        dst |= saturate_cast<uchar>(g) << 8;
+        dst |= saturate_cast<uchar>(r) << ((bidx ^ 2) * 8);
 
-            return dst;
-        }
-        template <int bidx, typename T> static __device__ __forceinline__ void YUV2RGBConvert(const T& src, float* dst)
-        {
-            dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[3];
-            dst[1] = src.x + (src.z - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[1];
-            dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[0];
-        }
+        return dst;
+    }
+    template <int bidx, typename T> static __device__ __forceinline__ void YUV2RGBConvert(const T& src, float* dst)
+    {
+        dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[3];
+        dst[1] = src.x + (src.z - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[1];
+        dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[0];
+    }
 
-        template <typename T, int scn, int dcn, int bidx> struct YUV2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    template <typename T, int scn, int dcn, int bidx> struct YUV2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                YUV2RGBConvert<bidx>(src, &dst.x);
-                setAlpha(dst, ColorChannel<T>::max());
+            YUV2RGBConvert<bidx>(src, &dst.x);
+            setAlpha(dst, ColorChannel<T>::max());
 
-                return dst;
-            }
-        };
-        template <int bidx> struct YUV2RGB<uchar, 4, 4, bidx> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx> struct YUV2RGB<uchar, 4, 4, bidx> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint src) const
         {
-            __device__ __forceinline__ uint operator ()(uint src) const
-            {
-                return YUV2RGBConvert<bidx>(src);
-            }
-        };
-    }
+            return YUV2RGBConvert<bidx>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -578,63 +579,63 @@ namespace cv { namespace gpu { namespace device
 
 ///////////////////////////////////// RGB <-> YCrCb //////////////////////////////////////
     
-    namespace detail
+namespace detail
+{
+    __constant__ float c_RGB2YCrCbCoeffs_f[5] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
+    __constant__ int   c_RGB2YCrCbCoeffs_i[5] = {R2Y, G2Y, B2Y, 11682, 9241};
+
+    template <int bidx, typename T, typename D> static __device__ void RGB2YCrCbConvert(const T* src, D& dst)
     {
-        __constant__ float c_RGB2YCrCbCoeffs_f[5] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
-        __constant__ int   c_RGB2YCrCbCoeffs_i[5] = {R2Y, G2Y, B2Y, 11682, 9241};
+        const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
 
-        template <int bidx, typename T, typename D> static __device__ void RGB2YCrCbConvert(const T* src, D& dst)
-        {
-            const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
+        const int Y = CV_DESCALE(src[0] * c_RGB2YCrCbCoeffs_i[bidx^2] + src[1] * c_RGB2YCrCbCoeffs_i[1] + src[2] * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
+        const int Cr = CV_DESCALE((src[bidx^2] - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
+        const int Cb = CV_DESCALE((src[bidx] - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
 
-            const int Y = CV_DESCALE(src[0] * c_RGB2YCrCbCoeffs_i[bidx^2] + src[1] * c_RGB2YCrCbCoeffs_i[1] + src[2] * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
-            const int Cr = CV_DESCALE((src[bidx^2] - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
-            const int Cb = CV_DESCALE((src[bidx] - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
+        dst.x = saturate_cast<T>(Y);
+        dst.y = saturate_cast<T>(Cr);
+        dst.z = saturate_cast<T>(Cb);
+    }
+    template <int bidx> static __device__ uint RGB2YCrCbConvert(uint src)
+    {
+        const int delta = ColorChannel<uchar>::half() * (1 << yuv_shift);
 
-            dst.x = saturate_cast<T>(Y);
-            dst.y = saturate_cast<T>(Cr);
-            dst.z = saturate_cast<T>(Cb);
-        }
-        template <int bidx> static __device__ uint RGB2YCrCbConvert(uint src)
-        {
-            const int delta = ColorChannel<uchar>::half() * (1 << yuv_shift);
+        const uint Y = CV_DESCALE((0xffu & src) * c_RGB2YCrCbCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YCrCbCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
+        const uint Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
+        const uint Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
 
-            const uint Y = CV_DESCALE((0xffu & src) * c_RGB2YCrCbCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YCrCbCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
-            const uint Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
-            const uint Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
+        uint dst = 0;
 
-            uint dst = 0;
+        dst |= saturate_cast<uchar>(Y);
+        dst |= saturate_cast<uchar>(Cr) << 8;
+        dst |= saturate_cast<uchar>(Cb) << 16;
 
-            dst |= saturate_cast<uchar>(Y);
-            dst |= saturate_cast<uchar>(Cr) << 8;
-            dst |= saturate_cast<uchar>(Cb) << 16;
+        return dst;
+    }
+    template <int bidx, typename D> static __device__ __forceinline__ void RGB2YCrCbConvert(const float* src, D& dst)
+    {
+        dst.x = src[0] * c_RGB2YCrCbCoeffs_f[bidx^2] + src[1] * c_RGB2YCrCbCoeffs_f[1] + src[2] * c_RGB2YCrCbCoeffs_f[bidx];
+        dst.y = (src[bidx^2] - dst.x) * c_RGB2YCrCbCoeffs_f[3] + ColorChannel<float>::half();
+        dst.z = (src[bidx] - dst.x) * c_RGB2YCrCbCoeffs_f[4] + ColorChannel<float>::half();
+    }
 
+    template <typename T, int scn, int dcn, int bidx> struct RGB2YCrCb : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
+        {
+            typename TypeVec<T, dcn>::vec_type dst;
+            RGB2YCrCbConvert<bidx>(&src.x, dst);
             return dst;
         }
-        template <int bidx, typename D> static __device__ __forceinline__ void RGB2YCrCbConvert(const float* src, D& dst)
+    };
+    template <int bidx> struct RGB2YCrCb<uchar, 4, 4, bidx> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint src) const
         {
-            dst.x = src[0] * c_RGB2YCrCbCoeffs_f[bidx^2] + src[1] * c_RGB2YCrCbCoeffs_f[1] + src[2] * c_RGB2YCrCbCoeffs_f[bidx];
-            dst.y = (src[bidx^2] - dst.x) * c_RGB2YCrCbCoeffs_f[3] + ColorChannel<float>::half();
-            dst.z = (src[bidx] - dst.x) * c_RGB2YCrCbCoeffs_f[4] + ColorChannel<float>::half();
+            return RGB2YCrCbConvert<bidx>(src);
         }
-
-        template <typename T, int scn, int dcn, int bidx> struct RGB2YCrCb : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
-        {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
-                RGB2YCrCbConvert<bidx>(&src.x, dst);
-                return dst;
-            }
-        };
-        template <int bidx> struct RGB2YCrCb<uchar, 4, 4, bidx> : unary_function<uint, uint>
-        {
-            __device__ __forceinline__ uint operator ()(uint src) const
-            {
-                return RGB2YCrCbConvert<bidx>(src);
-            }
-        };
-    }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -646,66 +647,66 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
-    {
-        __constant__ float c_YCrCb2RGBCoeffs_f[5] = {1.403f, -0.714f, -0.344f, 1.773f};
-        __constant__ int   c_YCrCb2RGBCoeffs_i[5] = {22987, -11698, -5636, 29049};
+namespace detail
+{
+    __constant__ float c_YCrCb2RGBCoeffs_f[5] = {1.403f, -0.714f, -0.344f, 1.773f};
+    __constant__ int   c_YCrCb2RGBCoeffs_i[5] = {22987, -11698, -5636, 29049};
 
-        template <int bidx, typename T, typename D> static __device__ void YCrCb2RGBConvert(const T& src, D* dst)
-        {
-            const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
-            const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
-            const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
+    template <int bidx, typename T, typename D> static __device__ void YCrCb2RGBConvert(const T& src, D* dst)
+    {
+        const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
+        const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
+        const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
 
-            dst[bidx] = saturate_cast<D>(b);
-            dst[1] = saturate_cast<D>(g);
-            dst[bidx^2] = saturate_cast<D>(r);
-        }
-        template <int bidx> static __device__ uint YCrCb2RGBConvert(uint src)
-        {
-            const int x = 0xff & (src);
-            const int y = 0xff & (src >> 8);
-            const int z = 0xff & (src >> 16);
-            
-            const uint b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
-            const uint g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
-            const uint r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
+        dst[bidx] = saturate_cast<D>(b);
+        dst[1] = saturate_cast<D>(g);
+        dst[bidx^2] = saturate_cast<D>(r);
+    }
+    template <int bidx> static __device__ uint YCrCb2RGBConvert(uint src)
+    {
+        const int x = 0xff & (src);
+        const int y = 0xff & (src >> 8);
+        const int z = 0xff & (src >> 16);
+        
+        const uint b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
+        const uint g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
+        const uint r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
 
-            uint dst = 0xffu << 24;
+        uint dst = 0xffu << 24;
 
-            dst |= saturate_cast<uchar>(b) << (bidx * 8);
-            dst |= saturate_cast<uchar>(g) << 8;
-            dst |= saturate_cast<uchar>(r) << ((bidx ^ 2) * 8);
+        dst |= saturate_cast<uchar>(b) << (bidx * 8);
+        dst |= saturate_cast<uchar>(g) << 8;
+        dst |= saturate_cast<uchar>(r) << ((bidx ^ 2) * 8);
 
-            return dst;
-        }
-        template <int bidx, typename T> __device__ __forceinline__ void YCrCb2RGBConvert(const T& src, float* dst)
-        {
-            dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[3];
-            dst[1] = src.x + (src.z - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[1];
-            dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[0];
-        }
+        return dst;
+    }
+    template <int bidx, typename T> __device__ __forceinline__ void YCrCb2RGBConvert(const T& src, float* dst)
+    {
+        dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[3];
+        dst[1] = src.x + (src.z - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[1];
+        dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[0];
+    }
 
-        template <typename T, int scn, int dcn, int bidx> struct YCrCb2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    template <typename T, int scn, int dcn, int bidx> struct YCrCb2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator ()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                YCrCb2RGBConvert<bidx>(src, &dst.x);
-                setAlpha(dst, ColorChannel<T>::max());
+            YCrCb2RGBConvert<bidx>(src, &dst.x);
+            setAlpha(dst, ColorChannel<T>::max());
 
-                return dst;
-            }
-        };
-        template <int bidx> struct YCrCb2RGB<uchar, 4, 4, bidx> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx> struct YCrCb2RGB<uchar, 4, 4, bidx> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint src) const
         {
-            __device__ __forceinline__ uint operator ()(uint src) const
-            {
-                return YCrCb2RGBConvert<bidx>(src);
-            }
-        };
-    }
+            return YCrCb2RGBConvert<bidx>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -719,61 +720,61 @@ namespace cv { namespace gpu { namespace device
 
 ////////////////////////////////////// RGB <-> XYZ ///////////////////////////////////////
 
-    namespace detail
-    {
-        __constant__ float c_RGB2XYZ_D65f[9] = { 0.412453f, 0.357580f, 0.180423f, 0.212671f, 0.715160f, 0.072169f, 0.019334f, 0.119193f, 0.950227f };
-        __constant__ int   c_RGB2XYZ_D65i[9] = { 1689, 1465, 739, 871, 2929, 296, 79, 488, 3892 };
+namespace detail
+{
+    __constant__ float c_RGB2XYZ_D65f[9] = { 0.412453f, 0.357580f, 0.180423f, 0.212671f, 0.715160f, 0.072169f, 0.019334f, 0.119193f, 0.950227f };
+    __constant__ int   c_RGB2XYZ_D65i[9] = { 1689, 1465, 739, 871, 2929, 296, 79, 488, 3892 };
 
-        template <int bidx, typename T, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const T* src, D& dst)
-        {
-            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)
-        {
-            const uint b = 0xffu & (src >> (bidx * 8));
-            const uint g = 0xffu & (src >> 8);
-            const uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
+    template <int bidx, typename T, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const T* src, D& dst)
+    {
+        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)
+    {
+        const uint b = 0xffu & (src >> (bidx * 8));
+        const uint g = 0xffu & (src >> 8);
+        const uint r = 0xffu & (src >> ((bidx ^ 2) * 8));
 
-            const uint x = saturate_cast<uchar>(CV_DESCALE(r * c_RGB2XYZ_D65i[0] + g * c_RGB2XYZ_D65i[1] + b * c_RGB2XYZ_D65i[2], xyz_shift));
-            const uint y = saturate_cast<uchar>(CV_DESCALE(r * c_RGB2XYZ_D65i[3] + g * c_RGB2XYZ_D65i[4] + b * c_RGB2XYZ_D65i[5], xyz_shift));
-            const uint z = saturate_cast<uchar>(CV_DESCALE(r * c_RGB2XYZ_D65i[6] + g * c_RGB2XYZ_D65i[7] + b * c_RGB2XYZ_D65i[8], xyz_shift));
+        const uint x = saturate_cast<uchar>(CV_DESCALE(r * c_RGB2XYZ_D65i[0] + g * c_RGB2XYZ_D65i[1] + b * c_RGB2XYZ_D65i[2], xyz_shift));
+        const uint y = saturate_cast<uchar>(CV_DESCALE(r * c_RGB2XYZ_D65i[3] + g * c_RGB2XYZ_D65i[4] + b * c_RGB2XYZ_D65i[5], xyz_shift));
+        const uint z = saturate_cast<uchar>(CV_DESCALE(r * c_RGB2XYZ_D65i[6] + g * c_RGB2XYZ_D65i[7] + b * c_RGB2XYZ_D65i[8], xyz_shift));
 
-            uint dst = 0;
+        uint dst = 0;
 
-            dst |= x;
-            dst |= y << 8;
-            dst |= z << 16;
+        dst |= x;
+        dst |= y << 8;
+        dst |= z << 16;
 
-            return dst;
-        }
-        template <int bidx, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const float* src, D& dst)
-        {
-            dst.x = src[bidx^2] * c_RGB2XYZ_D65f[0] + src[1] * c_RGB2XYZ_D65f[1] + src[bidx] * c_RGB2XYZ_D65f[2];
-            dst.y = src[bidx^2] * c_RGB2XYZ_D65f[3] + src[1] * c_RGB2XYZ_D65f[4] + src[bidx] * c_RGB2XYZ_D65f[5];
-            dst.z = src[bidx^2] * c_RGB2XYZ_D65f[6] + src[1] * c_RGB2XYZ_D65f[7] + src[bidx] * c_RGB2XYZ_D65f[8];
-        }
+        return dst;
+    }
+    template <int bidx, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const float* src, D& dst)
+    {
+        dst.x = src[bidx^2] * c_RGB2XYZ_D65f[0] + src[1] * c_RGB2XYZ_D65f[1] + src[bidx] * c_RGB2XYZ_D65f[2];
+        dst.y = src[bidx^2] * c_RGB2XYZ_D65f[3] + src[1] * c_RGB2XYZ_D65f[4] + src[bidx] * c_RGB2XYZ_D65f[5];
+        dst.z = src[bidx^2] * c_RGB2XYZ_D65f[6] + src[1] * c_RGB2XYZ_D65f[7] + src[bidx] * c_RGB2XYZ_D65f[8];
+    }
 
-        template <typename T, int scn, int dcn, int bidx> struct RGB2XYZ : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    template <typename T, int scn, int dcn, int bidx> struct RGB2XYZ : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                RGB2XYZConvert<bidx>(&src.x, dst);
+            RGB2XYZConvert<bidx>(&src.x, dst);
 
-                return dst;
-            }
-        };
-        template <int bidx> struct RGB2XYZ<uchar, 4, 4, bidx> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx> struct RGB2XYZ<uchar, 4, 4, bidx> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                return RGB2XYZConvert<bidx>(src);
-            }
-        };
-    }
+            return RGB2XYZConvert<bidx>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -785,62 +786,62 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
-    {
-        __constant__ float c_XYZ2sRGB_D65f[9] = { 3.240479f, -1.53715f, -0.498535f, -0.969256f, 1.875991f, 0.041556f, 0.055648f, -0.204043f, 1.057311f };
-        __constant__ int   c_XYZ2sRGB_D65i[9] = { 13273, -6296, -2042, -3970, 7684, 170, 228, -836, 4331 };
+namespace detail
+{
+    __constant__ float c_XYZ2sRGB_D65f[9] = { 3.240479f, -1.53715f, -0.498535f, -0.969256f, 1.875991f, 0.041556f, 0.055648f, -0.204043f, 1.057311f };
+    __constant__ int   c_XYZ2sRGB_D65i[9] = { 13273, -6296, -2042, -3970, 7684, 170, 228, -836, 4331 };
 
-        template <int bidx, typename T, typename D> static __device__ __forceinline__ void XYZ2RGBConvert(const T& src, D* dst)
-        {
-            dst[bidx^2] = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[0] + src.y * c_XYZ2sRGB_D65i[1] + src.z * c_XYZ2sRGB_D65i[2], xyz_shift));
-	        dst[1]      = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[3] + src.y * c_XYZ2sRGB_D65i[4] + src.z * c_XYZ2sRGB_D65i[5], xyz_shift));
-	        dst[bidx]   = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[6] + src.y * c_XYZ2sRGB_D65i[7] + src.z * c_XYZ2sRGB_D65i[8], xyz_shift));
-        }
-        template <int bidx> static __device__ __forceinline__ uint XYZ2RGBConvert(uint src)
-        {
-            const int x = 0xff & src;
-            const int y = 0xff & (src >> 8);
-            const int z = 0xff & (src >> 16);
+    template <int bidx, typename T, typename D> static __device__ __forceinline__ void XYZ2RGBConvert(const T& src, D* dst)
+    {
+        dst[bidx^2] = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[0] + src.y * c_XYZ2sRGB_D65i[1] + src.z * c_XYZ2sRGB_D65i[2], xyz_shift));
+        dst[1]      = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[3] + src.y * c_XYZ2sRGB_D65i[4] + src.z * c_XYZ2sRGB_D65i[5], xyz_shift));
+        dst[bidx]   = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[6] + src.y * c_XYZ2sRGB_D65i[7] + src.z * c_XYZ2sRGB_D65i[8], xyz_shift));
+    }
+    template <int bidx> static __device__ __forceinline__ uint XYZ2RGBConvert(uint src)
+    {
+        const int x = 0xff & src;
+        const int y = 0xff & (src >> 8);
+        const int z = 0xff & (src >> 16);
 
-            const uint r = saturate_cast<uchar>(CV_DESCALE(x * c_XYZ2sRGB_D65i[0] + y * c_XYZ2sRGB_D65i[1] + z * c_XYZ2sRGB_D65i[2], xyz_shift));
-	        const uint g = saturate_cast<uchar>(CV_DESCALE(x * c_XYZ2sRGB_D65i[3] + y * c_XYZ2sRGB_D65i[4] + z * c_XYZ2sRGB_D65i[5], xyz_shift));
-	        const uint b = saturate_cast<uchar>(CV_DESCALE(x * c_XYZ2sRGB_D65i[6] + y * c_XYZ2sRGB_D65i[7] + z * c_XYZ2sRGB_D65i[8], xyz_shift));
+        const uint r = saturate_cast<uchar>(CV_DESCALE(x * c_XYZ2sRGB_D65i[0] + y * c_XYZ2sRGB_D65i[1] + z * c_XYZ2sRGB_D65i[2], xyz_shift));
+        const uint g = saturate_cast<uchar>(CV_DESCALE(x * c_XYZ2sRGB_D65i[3] + y * c_XYZ2sRGB_D65i[4] + z * c_XYZ2sRGB_D65i[5], xyz_shift));
+        const uint b = saturate_cast<uchar>(CV_DESCALE(x * c_XYZ2sRGB_D65i[6] + y * c_XYZ2sRGB_D65i[7] + z * c_XYZ2sRGB_D65i[8], xyz_shift));
 
-            uint dst = 0xffu << 24;
+        uint dst = 0xffu << 24;
 
-            dst |= b << (bidx * 8);
-            dst |= g << 8;
-            dst |= r << ((bidx ^ 2) * 8);
+        dst |= b << (bidx * 8);
+        dst |= g << 8;
+        dst |= r << ((bidx ^ 2) * 8);
 
-            return dst;
-        }
-        template <int bidx, typename T> static __device__ __forceinline__ void XYZ2RGBConvert(const T& src, float* dst)
-        {
-            dst[bidx^2] = src.x * c_XYZ2sRGB_D65f[0] + src.y * c_XYZ2sRGB_D65f[1] + src.z * c_XYZ2sRGB_D65f[2];
-	        dst[1]      = src.x * c_XYZ2sRGB_D65f[3] + src.y * c_XYZ2sRGB_D65f[4] + src.z * c_XYZ2sRGB_D65f[5];
-	        dst[bidx]   = src.x * c_XYZ2sRGB_D65f[6] + src.y * c_XYZ2sRGB_D65f[7] + src.z * c_XYZ2sRGB_D65f[8];
-        }
+        return dst;
+    }
+    template <int bidx, typename T> static __device__ __forceinline__ void XYZ2RGBConvert(const T& src, float* dst)
+    {
+        dst[bidx^2] = src.x * c_XYZ2sRGB_D65f[0] + src.y * c_XYZ2sRGB_D65f[1] + src.z * c_XYZ2sRGB_D65f[2];
+        dst[1]      = src.x * c_XYZ2sRGB_D65f[3] + src.y * c_XYZ2sRGB_D65f[4] + src.z * c_XYZ2sRGB_D65f[5];
+        dst[bidx]   = src.x * c_XYZ2sRGB_D65f[6] + src.y * c_XYZ2sRGB_D65f[7] + src.z * c_XYZ2sRGB_D65f[8];
+    }
 
-        template <typename T, int scn, int dcn, int bidx> struct XYZ2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    template <typename T, int scn, int dcn, int bidx> struct XYZ2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                XYZ2RGBConvert<bidx>(src, &dst.x);
-                setAlpha(dst, ColorChannel<T>::max());
+            XYZ2RGBConvert<bidx>(src, &dst.x);
+            setAlpha(dst, ColorChannel<T>::max());
 
-                return dst;
-            }
-        };
-        template <int bidx> struct XYZ2RGB<uchar, 4, 4, bidx> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx> struct XYZ2RGB<uchar, 4, 4, bidx> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                return XYZ2RGBConvert<bidx>(src);
-            }
-        };
-    }
+            return XYZ2RGBConvert<bidx>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -854,123 +855,123 @@ namespace cv { namespace gpu { namespace device
 
 ////////////////////////////////////// RGB <-> HSV ///////////////////////////////////////
 
-    namespace detail
-    {
-        __constant__ int c_HsvDivTable   [256] = {0, 1044480, 522240, 348160, 261120, 208896, 174080, 149211, 130560, 116053, 104448, 94953, 87040, 80345, 74606, 69632, 65280, 61440, 58027, 54973, 52224, 49737, 47476, 45412, 43520, 41779, 40172, 38684, 37303, 36017, 34816, 33693, 32640, 31651, 30720, 29842, 29013, 28229, 27486, 26782, 26112, 25475, 24869, 24290, 23738, 23211, 22706, 22223, 21760, 21316, 20890, 20480, 20086, 19707, 19342, 18991, 18651, 18324, 18008, 17703, 17408, 17123, 16846, 16579, 16320, 16069, 15825, 15589, 15360, 15137, 14921, 14711, 14507, 14308, 14115, 13926, 13743, 13565, 13391, 13221, 13056, 12895, 12738, 12584, 12434, 12288, 12145, 12006, 11869, 11736, 11605, 11478, 11353, 11231, 11111, 10995, 10880, 10768, 10658, 10550, 10445, 10341, 10240, 10141, 10043, 9947, 9854, 9761, 9671, 9582, 9495, 9410, 9326, 9243, 9162, 9082, 9004, 8927, 8852, 8777, 8704, 8632, 8561, 8492, 8423, 8356, 8290, 8224, 8160, 8097, 8034, 7973, 7913, 7853, 7795, 7737, 7680, 7624, 7569, 7514, 7461, 7408, 7355, 7304, 7253, 7203, 7154, 7105, 7057, 7010, 6963, 6917, 6872, 6827, 6782, 6739, 6695, 6653, 6611, 6569, 6528, 6487, 6447, 6408, 6369, 6330, 6292, 6254, 6217, 6180, 6144, 6108, 6073, 6037, 6003, 5968, 5935, 5901, 5868, 5835, 5803, 5771, 5739, 5708, 5677, 5646, 5615, 5585, 5556, 5526, 5497, 5468, 5440, 5412, 5384, 5356, 5329, 5302, 5275, 5249, 5222, 5196, 5171, 5145, 5120, 5095, 5070, 5046, 5022, 4998, 4974, 4950, 4927, 4904, 4881, 4858, 4836, 4813, 4791, 4769, 4748, 4726, 4705, 4684, 4663, 4642, 4622, 4601, 4581, 4561, 4541, 4522, 4502, 4483, 4464, 4445, 4426, 4407, 4389, 4370, 4352, 4334, 4316, 4298, 4281, 4263, 4246, 4229, 4212, 4195, 4178, 4161, 4145, 4128, 4112, 4096};
-        __constant__ int c_HsvDivTable180[256] = {0, 122880, 61440, 40960, 30720, 24576, 20480, 17554, 15360, 13653, 12288, 11171, 10240, 9452, 8777, 8192, 7680, 7228, 6827, 6467, 6144, 5851, 5585, 5343, 5120, 4915, 4726, 4551, 4389, 4237, 4096, 3964, 3840, 3724, 3614, 3511, 3413, 3321, 3234, 3151, 3072, 2997, 2926, 2858, 2793, 2731, 2671, 2614, 2560, 2508, 2458, 2409, 2363, 2318, 2276, 2234, 2194, 2156, 2119, 2083, 2048, 2014, 1982, 1950, 1920, 1890, 1862, 1834, 1807, 1781, 1755, 1731, 1707, 1683, 1661, 1638, 1617, 1596, 1575, 1555, 1536, 1517, 1499, 1480, 1463, 1446, 1429, 1412, 1396, 1381, 1365, 1350, 1336, 1321, 1307, 1293, 1280, 1267, 1254, 1241, 1229, 1217, 1205, 1193, 1182, 1170, 1159, 1148, 1138, 1127, 1117, 1107, 1097, 1087, 1078, 1069, 1059, 1050, 1041, 1033, 1024, 1016, 1007, 999, 991, 983, 975, 968, 960, 953, 945, 938, 931, 924, 917, 910, 904, 897, 890, 884, 878, 871, 865, 859, 853, 847, 842, 836, 830, 825, 819, 814, 808, 803, 798, 793, 788, 783, 778, 773, 768, 763, 759, 754, 749, 745, 740, 736, 731, 727, 723, 719, 714, 710, 706, 702, 698, 694, 690, 686, 683, 679, 675, 671, 668, 664, 661, 657, 654, 650, 647, 643, 640, 637, 633, 630, 627, 624, 621, 617, 614, 611, 608, 605, 602, 599, 597, 594, 591, 588, 585, 582, 580, 577, 574, 572, 569, 566, 564, 561, 559, 556, 554, 551, 549, 546, 544, 541, 539, 537, 534, 532, 530, 527, 525, 523, 521, 518, 516, 514, 512, 510, 508, 506, 504, 502, 500, 497, 495, 493, 492, 490, 488, 486, 484, 482};
-        __constant__ int c_HsvDivTable256[256] = {0, 174763, 87381, 58254, 43691, 34953, 29127, 24966, 21845, 19418, 17476, 15888, 14564, 13443, 12483, 11651, 10923, 10280, 9709, 9198, 8738, 8322, 7944, 7598, 7282, 6991, 6722, 6473, 6242, 6026, 5825, 5638, 5461, 5296, 5140, 4993, 4855, 4723, 4599, 4481, 4369, 4263, 4161, 4064, 3972, 3884, 3799, 3718, 3641, 3567, 3495, 3427, 3361, 3297, 3236, 3178, 3121, 3066, 3013, 2962, 2913, 2865, 2819, 2774, 2731, 2689, 2648, 2608, 2570, 2533, 2497, 2461, 2427, 2394, 2362, 2330, 2300, 2270, 2241, 2212, 2185, 2158, 2131, 2106, 2081, 2056, 2032, 2009, 1986, 1964, 1942, 1920, 1900, 1879, 1859, 1840, 1820, 1802, 1783, 1765, 1748, 1730, 1713, 1697, 1680, 1664, 1649, 1633, 1618, 1603, 1589, 1574, 1560, 1547, 1533, 1520, 1507, 1494, 1481, 1469, 1456, 1444, 1432, 1421, 1409, 1398, 1387, 1376, 1365, 1355, 1344, 1334, 1324, 1314, 1304, 1295, 1285, 1276, 1266, 1257, 1248, 1239, 1231, 1222, 1214, 1205, 1197, 1189, 1181, 1173, 1165, 1157, 1150, 1142, 1135, 1128, 1120, 1113, 1106, 1099, 1092, 1085, 1079, 1072, 1066, 1059, 1053, 1046, 1040, 1034, 1028, 1022, 1016, 1010, 1004, 999, 993, 987, 982, 976, 971, 966, 960, 955, 950, 945, 940, 935, 930, 925, 920, 915, 910, 906, 901, 896, 892, 887, 883, 878, 874, 869, 865, 861, 857, 853, 848, 844, 840, 836, 832, 828, 824, 820, 817, 813, 809, 805, 802, 798, 794, 791, 787, 784, 780, 777, 773, 770, 767, 763, 760, 757, 753, 750, 747, 744, 741, 737, 734, 731, 728, 725, 722, 719, 716, 713, 710, 708, 705, 702, 699, 696, 694, 691, 688, 685};
-
-        template <int bidx, int hr, typename D> static __device__ void RGB2HSVConvert(const uchar* src, D& dst)
-        {
-            const int hsv_shift = 12;
-            const int* hdiv_table = hr == 180 ? c_HsvDivTable180 : c_HsvDivTable256;
-
-            int b = src[bidx], g = src[1], r = src[bidx^2];
-            int h, s, v = b;
-            int vmin = b, diff;
-            int vr, vg;
-
-            v = ::max(v, g);
-            v = ::max(v, r);
-            vmin = ::min(vmin, g);
-            vmin = ::min(vmin, r);
-
-            diff = v - vmin;
-            vr = (v == r) * -1;
-            vg = (v == g) * -1;
-
-            s = (diff * c_HsvDivTable[v] + (1 << (hsv_shift-1))) >> hsv_shift;
-            h = (vr & (g - b)) + (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
-            h = (h * hdiv_table[diff] + (1 << (hsv_shift-1))) >> hsv_shift;
-            h += (h < 0) * hr;
-
-            dst.x = saturate_cast<uchar>(h);
-            dst.y = (uchar)s;
-            dst.z = (uchar)v;
-        }
-        template <int bidx, int hr> static __device__ uint RGB2HSVConvert(uint src)
-        {
-            const int hsv_shift = 12;
-            const int* hdiv_table = hr == 180 ? c_HsvDivTable180 : c_HsvDivTable256;
-
-            const int b = 0xff & (src >> (bidx * 8));
-            const int g = 0xff & (src >> 8);
-            const int r = 0xff & (src >> ((bidx ^ 2) * 8));
-            
-            int h, s, v = b;
-            int vmin = b, diff;
-            int vr, vg;
-
-            v = ::max(v, g);
-            v = ::max(v, r);
-            vmin = ::min(vmin, g);
-            vmin = ::min(vmin, r);
-
-            diff = v - vmin;
-            vr = (v == r) * -1;
-            vg = (v == g) * -1;
-
-            s = (diff * c_HsvDivTable[v] + (1 << (hsv_shift-1))) >> hsv_shift;
-            h = (vr & (g - b)) + (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
-            h = (h * hdiv_table[diff] + (1 << (hsv_shift-1))) >> hsv_shift;
-            h += (h < 0) * hr;
-
-            uint dst = 0;
-
-            dst |= saturate_cast<uchar>(h);
-            dst |= (0xffu & s) << 8;
-            dst |= (0xffu & v) << 16;
+namespace detail
+{
+    __constant__ int c_HsvDivTable   [256] = {0, 1044480, 522240, 348160, 261120, 208896, 174080, 149211, 130560, 116053, 104448, 94953, 87040, 80345, 74606, 69632, 65280, 61440, 58027, 54973, 52224, 49737, 47476, 45412, 43520, 41779, 40172, 38684, 37303, 36017, 34816, 33693, 32640, 31651, 30720, 29842, 29013, 28229, 27486, 26782, 26112, 25475, 24869, 24290, 23738, 23211, 22706, 22223, 21760, 21316, 20890, 20480, 20086, 19707, 19342, 18991, 18651, 18324, 18008, 17703, 17408, 17123, 16846, 16579, 16320, 16069, 15825, 15589, 15360, 15137, 14921, 14711, 14507, 14308, 14115, 13926, 13743, 13565, 13391, 13221, 13056, 12895, 12738, 12584, 12434, 12288, 12145, 12006, 11869, 11736, 11605, 11478, 11353, 11231, 11111, 10995, 10880, 10768, 10658, 10550, 10445, 10341, 10240, 10141, 10043, 9947, 9854, 9761, 9671, 9582, 9495, 9410, 9326, 9243, 9162, 9082, 9004, 8927, 8852, 8777, 8704, 8632, 8561, 8492, 8423, 8356, 8290, 8224, 8160, 8097, 8034, 7973, 7913, 7853, 7795, 7737, 7680, 7624, 7569, 7514, 7461, 7408, 7355, 7304, 7253, 7203, 7154, 7105, 7057, 7010, 6963, 6917, 6872, 6827, 6782, 6739, 6695, 6653, 6611, 6569, 6528, 6487, 6447, 6408, 6369, 6330, 6292, 6254, 6217, 6180, 6144, 6108, 6073, 6037, 6003, 5968, 5935, 5901, 5868, 5835, 5803, 5771, 5739, 5708, 5677, 5646, 5615, 5585, 5556, 5526, 5497, 5468, 5440, 5412, 5384, 5356, 5329, 5302, 5275, 5249, 5222, 5196, 5171, 5145, 5120, 5095, 5070, 5046, 5022, 4998, 4974, 4950, 4927, 4904, 4881, 4858, 4836, 4813, 4791, 4769, 4748, 4726, 4705, 4684, 4663, 4642, 4622, 4601, 4581, 4561, 4541, 4522, 4502, 4483, 4464, 4445, 4426, 4407, 4389, 4370, 4352, 4334, 4316, 4298, 4281, 4263, 4246, 4229, 4212, 4195, 4178, 4161, 4145, 4128, 4112, 4096};
+    __constant__ int c_HsvDivTable180[256] = {0, 122880, 61440, 40960, 30720, 24576, 20480, 17554, 15360, 13653, 12288, 11171, 10240, 9452, 8777, 8192, 7680, 7228, 6827, 6467, 6144, 5851, 5585, 5343, 5120, 4915, 4726, 4551, 4389, 4237, 4096, 3964, 3840, 3724, 3614, 3511, 3413, 3321, 3234, 3151, 3072, 2997, 2926, 2858, 2793, 2731, 2671, 2614, 2560, 2508, 2458, 2409, 2363, 2318, 2276, 2234, 2194, 2156, 2119, 2083, 2048, 2014, 1982, 1950, 1920, 1890, 1862, 1834, 1807, 1781, 1755, 1731, 1707, 1683, 1661, 1638, 1617, 1596, 1575, 1555, 1536, 1517, 1499, 1480, 1463, 1446, 1429, 1412, 1396, 1381, 1365, 1350, 1336, 1321, 1307, 1293, 1280, 1267, 1254, 1241, 1229, 1217, 1205, 1193, 1182, 1170, 1159, 1148, 1138, 1127, 1117, 1107, 1097, 1087, 1078, 1069, 1059, 1050, 1041, 1033, 1024, 1016, 1007, 999, 991, 983, 975, 968, 960, 953, 945, 938, 931, 924, 917, 910, 904, 897, 890, 884, 878, 871, 865, 859, 853, 847, 842, 836, 830, 825, 819, 814, 808, 803, 798, 793, 788, 783, 778, 773, 768, 763, 759, 754, 749, 745, 740, 736, 731, 727, 723, 719, 714, 710, 706, 702, 698, 694, 690, 686, 683, 679, 675, 671, 668, 664, 661, 657, 654, 650, 647, 643, 640, 637, 633, 630, 627, 624, 621, 617, 614, 611, 608, 605, 602, 599, 597, 594, 591, 588, 585, 582, 580, 577, 574, 572, 569, 566, 564, 561, 559, 556, 554, 551, 549, 546, 544, 541, 539, 537, 534, 532, 530, 527, 525, 523, 521, 518, 516, 514, 512, 510, 508, 506, 504, 502, 500, 497, 495, 493, 492, 490, 488, 486, 484, 482};
+    __constant__ int c_HsvDivTable256[256] = {0, 174763, 87381, 58254, 43691, 34953, 29127, 24966, 21845, 19418, 17476, 15888, 14564, 13443, 12483, 11651, 10923, 10280, 9709, 9198, 8738, 8322, 7944, 7598, 7282, 6991, 6722, 6473, 6242, 6026, 5825, 5638, 5461, 5296, 5140, 4993, 4855, 4723, 4599, 4481, 4369, 4263, 4161, 4064, 3972, 3884, 3799, 3718, 3641, 3567, 3495, 3427, 3361, 3297, 3236, 3178, 3121, 3066, 3013, 2962, 2913, 2865, 2819, 2774, 2731, 2689, 2648, 2608, 2570, 2533, 2497, 2461, 2427, 2394, 2362, 2330, 2300, 2270, 2241, 2212, 2185, 2158, 2131, 2106, 2081, 2056, 2032, 2009, 1986, 1964, 1942, 1920, 1900, 1879, 1859, 1840, 1820, 1802, 1783, 1765, 1748, 1730, 1713, 1697, 1680, 1664, 1649, 1633, 1618, 1603, 1589, 1574, 1560, 1547, 1533, 1520, 1507, 1494, 1481, 1469, 1456, 1444, 1432, 1421, 1409, 1398, 1387, 1376, 1365, 1355, 1344, 1334, 1324, 1314, 1304, 1295, 1285, 1276, 1266, 1257, 1248, 1239, 1231, 1222, 1214, 1205, 1197, 1189, 1181, 1173, 1165, 1157, 1150, 1142, 1135, 1128, 1120, 1113, 1106, 1099, 1092, 1085, 1079, 1072, 1066, 1059, 1053, 1046, 1040, 1034, 1028, 1022, 1016, 1010, 1004, 999, 993, 987, 982, 976, 971, 966, 960, 955, 950, 945, 940, 935, 930, 925, 920, 915, 910, 906, 901, 896, 892, 887, 883, 878, 874, 869, 865, 861, 857, 853, 848, 844, 840, 836, 832, 828, 824, 820, 817, 813, 809, 805, 802, 798, 794, 791, 787, 784, 780, 777, 773, 770, 767, 763, 760, 757, 753, 750, 747, 744, 741, 737, 734, 731, 728, 725, 722, 719, 716, 713, 710, 708, 705, 702, 699, 696, 694, 691, 688, 685};
 
-            return dst;
-        }
-        template <int bidx, int hr, typename D> static __device__ void RGB2HSVConvert(const float* src, D& dst)
-        {
-            const float hscale = hr * (1.f / 360.f);
+    template <int bidx, int hr, typename D> static __device__ void RGB2HSVConvert(const uchar* src, D& dst)
+    {
+        const int hsv_shift = 12;
+        const int* hdiv_table = hr == 180 ? c_HsvDivTable180 : c_HsvDivTable256;
+
+        int b = src[bidx], g = src[1], r = src[bidx^2];
+        int h, s, v = b;
+        int vmin = b, diff;
+        int vr, vg;
+
+        v = ::max(v, g);
+        v = ::max(v, r);
+        vmin = ::min(vmin, g);
+        vmin = ::min(vmin, r);
+
+        diff = v - vmin;
+        vr = (v == r) * -1;
+        vg = (v == g) * -1;
+
+        s = (diff * c_HsvDivTable[v] + (1 << (hsv_shift-1))) >> hsv_shift;
+        h = (vr & (g - b)) + (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
+        h = (h * hdiv_table[diff] + (1 << (hsv_shift-1))) >> hsv_shift;
+        h += (h < 0) * hr;
+
+        dst.x = saturate_cast<uchar>(h);
+        dst.y = (uchar)s;
+        dst.z = (uchar)v;
+    }
+    template <int bidx, int hr> static __device__ uint RGB2HSVConvert(uint src)
+    {
+        const int hsv_shift = 12;
+        const int* hdiv_table = hr == 180 ? c_HsvDivTable180 : c_HsvDivTable256;
+
+        const int b = 0xff & (src >> (bidx * 8));
+        const int g = 0xff & (src >> 8);
+        const int r = 0xff & (src >> ((bidx ^ 2) * 8));
+        
+        int h, s, v = b;
+        int vmin = b, diff;
+        int vr, vg;
+
+        v = ::max(v, g);
+        v = ::max(v, r);
+        vmin = ::min(vmin, g);
+        vmin = ::min(vmin, r);
+
+        diff = v - vmin;
+        vr = (v == r) * -1;
+        vg = (v == g) * -1;
+
+        s = (diff * c_HsvDivTable[v] + (1 << (hsv_shift-1))) >> hsv_shift;
+        h = (vr & (g - b)) + (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
+        h = (h * hdiv_table[diff] + (1 << (hsv_shift-1))) >> hsv_shift;
+        h += (h < 0) * hr;
+
+        uint dst = 0;
+
+        dst |= saturate_cast<uchar>(h);
+        dst |= (0xffu & s) << 8;
+        dst |= (0xffu & v) << 16;
+
+        return dst;
+    }
+    template <int bidx, int hr, typename D> static __device__ void RGB2HSVConvert(const float* src, D& dst)
+    {
+        const float hscale = hr * (1.f / 360.f);
 
-            float b = src[bidx], g = src[1], r = src[bidx^2];
-            float h, s, v;
+        float b = src[bidx], g = src[1], r = src[bidx^2];
+        float h, s, v;
 
-            float vmin, diff;
+        float vmin, diff;
 
-            v = vmin = r;
-            v = fmax(v, g);
-            v = fmax(v, b);
-            vmin = fmin(vmin, g);
-            vmin = fmin(vmin, b);
+        v = vmin = r;
+        v = fmax(v, g);
+        v = fmax(v, b);
+        vmin = fmin(vmin, g);
+        vmin = fmin(vmin, b);
 
-            diff = v - vmin;
-            s = diff / (float)(::fabs(v) + numeric_limits<float>::epsilon());
-            diff = (float)(60. / (diff + numeric_limits<float>::epsilon()));
+        diff = v - vmin;
+        s = diff / (float)(::fabs(v) + numeric_limits<float>::epsilon());
+        diff = (float)(60. / (diff + numeric_limits<float>::epsilon()));
 
-            h  = (v == r) * (g - b) * diff;
-            h += (v != r && v == g) * ((b - r) * diff + 120.f);
-            h += (v != r && v != g) * ((r - g) * diff + 240.f);
-            h += (h < 0) * 360.f;
+        h  = (v == r) * (g - b) * diff;
+        h += (v != r && v == g) * ((b - r) * diff + 120.f);
+        h += (v != r && v != g) * ((r - g) * diff + 240.f);
+        h += (h < 0) * 360.f;
 
-            dst.x = h * hscale;
-            dst.y = s;
-            dst.z = v;
-        }
+        dst.x = h * hscale;
+        dst.y = s;
+        dst.z = v;
+    }
 
-        template <typename T, int scn, int dcn, int bidx, int hr> struct RGB2HSV : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    template <typename T, int scn, int dcn, int bidx, int hr> struct RGB2HSV : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                RGB2HSVConvert<bidx, hr>(&src.x, dst);
+            RGB2HSVConvert<bidx, hr>(&src.x, dst);
 
-                return dst;
-            }
-        };
-        template <int bidx, int hr> struct RGB2HSV<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx, int hr> struct RGB2HSV<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                return RGB2HSVConvert<bidx, hr>(src);
-            }
-        };
-    }
+            return RGB2HSVConvert<bidx, hr>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -1006,97 +1007,97 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
+namespace detail
+{
+    __constant__ int c_HsvSectorData[6][3] = { {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0} };
+
+    template <int bidx, int hr, typename T> static __device__ void HSV2RGBConvert(const T& src, float* dst)
     {
-        __constant__ int c_HsvSectorData[6][3] = { {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0} };
+        const float hscale = 6.f / hr;
+        
+        float h = src.x, s = src.y, v = src.z;
+        float b = v, g = v, r = v;
 
-        template <int bidx, int hr, typename T> static __device__ void HSV2RGBConvert(const T& src, float* dst)
+        if (s != 0)
         {
-            const float hscale = 6.f / hr;
-            
-            float h = src.x, s = src.y, v = src.z;
-            float b = v, g = v, r = v;
-
-            if (s != 0)
-            {
-                h *= hscale;
-
-                if( h < 0 )
-                    do h += 6; while( h < 0 );
-                else if( h >= 6 )
-                    do h -= 6; while( h >= 6 );
-
-                int sector = __float2int_rd(h);
-                h -= sector;
-
-                float tab[4];
-                tab[0] = v;
-                tab[1] = v * (1.f - s);
-                tab[2] = v * (1.f - s * h);
-                tab[3] = v * (1.f - s * (1.f - h));
-
-                b = tab[c_HsvSectorData[sector][0]];
-                g = tab[c_HsvSectorData[sector][1]];
-                r = tab[c_HsvSectorData[sector][2]];
-            }
-
-            dst[bidx] = b;
-            dst[1] = g;
-            dst[bidx^2] = r;
-        }
-        template <int bidx, int HR, typename T> static __device__ void HSV2RGBConvert(const T& src, uchar* dst)
-        {
-            float3 buf;
+            h *= hscale;
+
+            if( h < 0 )
+                do h += 6; while( h < 0 );
+            else if( h >= 6 )
+                do h -= 6; while( h >= 6 );
 
-            buf.x = src.x;
-            buf.y = src.y * (1.f / 255.f);
-            buf.z = src.z * (1.f / 255.f);
+            int sector = __float2int_rd(h);
+            h -= sector;
 
-            HSV2RGBConvert<bidx, HR>(buf, &buf.x);
+            float tab[4];
+            tab[0] = v;
+            tab[1] = v * (1.f - s);
+            tab[2] = v * (1.f - s * h);
+            tab[3] = v * (1.f - s * (1.f - h));
 
-            dst[0] = saturate_cast<uchar>(buf.x * 255.f);
-            dst[1] = saturate_cast<uchar>(buf.y * 255.f);
-            dst[2] = saturate_cast<uchar>(buf.z * 255.f);
+            b = tab[c_HsvSectorData[sector][0]];
+            g = tab[c_HsvSectorData[sector][1]];
+            r = tab[c_HsvSectorData[sector][2]];
         }
-        template <int bidx, int hr> static __device__ uint HSV2RGBConvert(uint src)
-        {
-            float3 buf;
 
-            buf.x = src & 0xff;
-            buf.y = ((src >> 8) & 0xff) * (1.f/255.f);
-            buf.z = ((src >> 16) & 0xff) * (1.f/255.f);
+        dst[bidx] = b;
+        dst[1] = g;
+        dst[bidx^2] = r;
+    }
+    template <int bidx, int HR, typename T> static __device__ void HSV2RGBConvert(const T& src, uchar* dst)
+    {
+        float3 buf;
 
-            HSV2RGBConvert<bidx, hr>(buf, &buf.x);
+        buf.x = src.x;
+        buf.y = src.y * (1.f / 255.f);
+        buf.z = src.z * (1.f / 255.f);
 
-            uint dst = 0xffu << 24;
+        HSV2RGBConvert<bidx, HR>(buf, &buf.x);
+
+        dst[0] = saturate_cast<uchar>(buf.x * 255.f);
+        dst[1] = saturate_cast<uchar>(buf.y * 255.f);
+        dst[2] = saturate_cast<uchar>(buf.z * 255.f);
+    }
+    template <int bidx, int hr> static __device__ uint HSV2RGBConvert(uint src)
+    {
+        float3 buf;
 
-            dst |= saturate_cast<uchar>(buf.x * 255.f);
-            dst |= saturate_cast<uchar>(buf.y * 255.f) << 8;
-            dst |= saturate_cast<uchar>(buf.z * 255.f) << 16;
+        buf.x = src & 0xff;
+        buf.y = ((src >> 8) & 0xff) * (1.f/255.f);
+        buf.z = ((src >> 16) & 0xff) * (1.f/255.f);
 
-            return dst;
-        }
+        HSV2RGBConvert<bidx, hr>(buf, &buf.x);
 
-        template <typename T, int scn, int dcn, int bidx, int hr> struct HSV2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+        uint dst = 0xffu << 24;
+
+        dst |= saturate_cast<uchar>(buf.x * 255.f);
+        dst |= saturate_cast<uchar>(buf.y * 255.f) << 8;
+        dst |= saturate_cast<uchar>(buf.z * 255.f) << 16;
+
+        return dst;
+    }
+
+    template <typename T, int scn, int dcn, int bidx, int hr> struct HSV2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                HSV2RGBConvert<bidx, hr>(src, &dst.x);
-                setAlpha(dst, ColorChannel<T>::max());
+            HSV2RGBConvert<bidx, hr>(src, &dst.x);
+            setAlpha(dst, ColorChannel<T>::max());
 
-                return dst;
-            }
-        };
-        template <int bidx, int hr> struct HSV2RGB<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx, int hr> struct HSV2RGB<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                return HSV2RGBConvert<bidx, hr>(src);
-            }
-        };
-    }
+            return HSV2RGBConvert<bidx, hr>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -1134,94 +1135,94 @@ namespace cv { namespace gpu { namespace device
 
 /////////////////////////////////////// RGB <-> HLS ////////////////////////////////////////
 
-    namespace detail
+namespace detail
+{
+    template <int bidx, int hr, typename D> static __device__ void RGB2HLSConvert(const float* src, D& dst)
     {
-        template <int bidx, int hr, typename D> static __device__ void RGB2HLSConvert(const float* src, D& dst)
-        {
-            const float hscale = hr * (1.f / 360.f);
-
-            float b = src[bidx], g = src[1], r = src[bidx^2];
-            float h = 0.f, s = 0.f, l;
-            float vmin, vmax, diff;
+        const float hscale = hr * (1.f / 360.f);
 
-            vmax = vmin = r;
-            vmax = fmax(vmax, g);
-            vmax = fmax(vmax, b);
-            vmin = fmin(vmin, g);
-            vmin = fmin(vmin, b);
+        float b = src[bidx], g = src[1], r = src[bidx^2];
+        float h = 0.f, s = 0.f, l;
+        float vmin, vmax, diff;
 
-            diff = vmax - vmin;
-            l = (vmax + vmin) * 0.5f;
+        vmax = vmin = r;
+        vmax = fmax(vmax, g);
+        vmax = fmax(vmax, b);
+        vmin = fmin(vmin, g);
+        vmin = fmin(vmin, b);
 
-            if (diff > numeric_limits<float>::epsilon())
-            {
-                s = (l < 0.5f) * diff / (vmax + vmin);
-                s += (l >= 0.5f) * diff / (2.0f - vmax - vmin);
+        diff = vmax - vmin;
+        l = (vmax + vmin) * 0.5f;
 
-                diff = 60.f / diff;
+        if (diff > numeric_limits<float>::epsilon())
+        {
+            s = (l < 0.5f) * diff / (vmax + vmin);
+            s += (l >= 0.5f) * diff / (2.0f - vmax - vmin);
 
-                h  = (vmax == r) * (g - b) * diff;
-                h += (vmax != r && vmax == g) * ((b - r) * diff + 120.f);
-                h += (vmax != r && vmax != g) * ((r - g) * diff + 240.f);
-                h += (h < 0.f) * 360.f;
-            }
+            diff = 60.f / diff;
 
-            dst.x = h * hscale;
-            dst.y = l;
-            dst.z = s;
+            h  = (vmax == r) * (g - b) * diff;
+            h += (vmax != r && vmax == g) * ((b - r) * diff + 120.f);
+            h += (vmax != r && vmax != g) * ((r - g) * diff + 240.f);
+            h += (h < 0.f) * 360.f;
         }
-        template <int bidx, int hr, typename D> static __device__ void RGB2HLSConvert(const uchar* src, D& dst)
-        {
-            float3 buf;
 
-            buf.x = src[0] * (1.f / 255.f);
-            buf.y = src[1] * (1.f / 255.f);
-            buf.z = src[2] * (1.f / 255.f);
+        dst.x = h * hscale;
+        dst.y = l;
+        dst.z = s;
+    }
+    template <int bidx, int hr, typename D> static __device__ void RGB2HLSConvert(const uchar* src, D& dst)
+    {
+        float3 buf;
 
-            RGB2HLSConvert<bidx, hr>(&buf.x, buf);
+        buf.x = src[0] * (1.f / 255.f);
+        buf.y = src[1] * (1.f / 255.f);
+        buf.z = src[2] * (1.f / 255.f);
 
-            dst.x = saturate_cast<uchar>(buf.x);
-            dst.y = saturate_cast<uchar>(buf.y*255.f);
-            dst.z = saturate_cast<uchar>(buf.z*255.f);
-        }
-        template <int bidx, int hr> static __device__ uint RGB2HLSConvert(uint src)
-        {
-            float3 buf;
+        RGB2HLSConvert<bidx, hr>(&buf.x, buf);
+
+        dst.x = saturate_cast<uchar>(buf.x);
+        dst.y = saturate_cast<uchar>(buf.y*255.f);
+        dst.z = saturate_cast<uchar>(buf.z*255.f);
+    }
+    template <int bidx, int hr> static __device__ uint RGB2HLSConvert(uint src)
+    {
+        float3 buf;
 
-            buf.x = (0xff & src) * (1.f / 255.f);
-            buf.y = (0xff & (src >> 8)) * (1.f / 255.f);
-            buf.z = (0xff & (src >> 16)) * (1.f / 255.f);
+        buf.x = (0xff & src) * (1.f / 255.f);
+        buf.y = (0xff & (src >> 8)) * (1.f / 255.f);
+        buf.z = (0xff & (src >> 16)) * (1.f / 255.f);
 
-            RGB2HLSConvert<bidx, hr>(&buf.x, buf);
+        RGB2HLSConvert<bidx, hr>(&buf.x, buf);
 
-            uint dst = 0xffu << 24;
+        uint dst = 0xffu << 24;
 
-            dst |= saturate_cast<uchar>(buf.x);
-            dst |= saturate_cast<uchar>(buf.y * 255.f) << 8;
-            dst |= saturate_cast<uchar>(buf.z * 255.f) << 16;
+        dst |= saturate_cast<uchar>(buf.x);
+        dst |= saturate_cast<uchar>(buf.y * 255.f) << 8;
+        dst |= saturate_cast<uchar>(buf.z * 255.f) << 16;
 
-            return dst;
-        }
+        return dst;
+    }
 
-        template <typename T, int scn, int dcn, int bidx, int hr> struct RGB2HLS : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    template <typename T, int scn, int dcn, int bidx, int hr> struct RGB2HLS : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                RGB2HLSConvert<bidx, hr>(&src.x, dst);
+            RGB2HLSConvert<bidx, hr>(&src.x, dst);
 
-                return dst;
-            }
-        };
-        template <int bidx, int hr> struct RGB2HLS<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx, int hr> struct RGB2HLS<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                return RGB2HLSConvert<bidx, hr>(src);
-            }
-        };
-    }
+            return RGB2HLSConvert<bidx, hr>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -1257,103 +1258,103 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    namespace detail
-    {
-        __constant__ int c_HlsSectorData[6][3] = { {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0} };
-
-        template <int bidx, int hr, typename T> static __device__ void HLS2RGBConvert(const T& src, float* dst)
-        {
-            const float hscale = 6.0f / hr;
+namespace detail
+{
+    __constant__ int c_HlsSectorData[6][3] = { {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0} };
 
-            float h = src.x, l = src.y, s = src.z;
-            float b = l, g = l, r = l;
+    template <int bidx, int hr, typename T> static __device__ void HLS2RGBConvert(const T& src, float* dst)
+    {
+        const float hscale = 6.0f / hr;
 
-            if (s != 0)
-            {
-                float p2  = (l <= 0.5f) * l * (1 + s);
-                      p2 += (l > 0.5f) * (l + s - l * s);
-                float p1 = 2 * l - p2;
+        float h = src.x, l = src.y, s = src.z;
+        float b = l, g = l, r = l;
 
-                h *= hscale;
+        if (s != 0)
+        {
+            float p2  = (l <= 0.5f) * l * (1 + s);
+                  p2 += (l > 0.5f) * (l + s - l * s);
+            float p1 = 2 * l - p2;
 
-                if( h < 0 )
-                    do h += 6; while( h < 0 );
-                else if( h >= 6 )
-                    do h -= 6; while( h >= 6 );
+            h *= hscale;
 
-                int sector;
-                sector = __float2int_rd(h);
+            if( h < 0 )
+                do h += 6; while( h < 0 );
+            else if( h >= 6 )
+                do h -= 6; while( h >= 6 );
 
-                h -= sector;
+            int sector;
+            sector = __float2int_rd(h);
 
-                float tab[4];
-                tab[0] = p2;
-                tab[1] = p1;
-                tab[2] = p1 + (p2 - p1) * (1 - h);
-                tab[3] = p1 + (p2 - p1) * h;
+            h -= sector;
 
-                b = tab[c_HlsSectorData[sector][0]];
-                g = tab[c_HlsSectorData[sector][1]];
-                r = tab[c_HlsSectorData[sector][2]];
-            }
+            float tab[4];
+            tab[0] = p2;
+            tab[1] = p1;
+            tab[2] = p1 + (p2 - p1) * (1 - h);
+            tab[3] = p1 + (p2 - p1) * h;
 
-            dst[bidx] = b;
-            dst[1] = g;
-            dst[bidx^2] = r;
+            b = tab[c_HlsSectorData[sector][0]];
+            g = tab[c_HlsSectorData[sector][1]];
+            r = tab[c_HlsSectorData[sector][2]];
         }
-        template <int bidx, int hr, typename T> static __device__ void HLS2RGBConvert(const T& src, uchar* dst)
-        {
-            float3 buf;
 
-            buf.x = src.x;
-            buf.y = src.y * (1.f / 255.f);
-            buf.z = src.z * (1.f / 255.f);
+        dst[bidx] = b;
+        dst[1] = g;
+        dst[bidx^2] = r;
+    }
+    template <int bidx, int hr, typename T> static __device__ void HLS2RGBConvert(const T& src, uchar* dst)
+    {
+        float3 buf;
 
-            HLS2RGBConvert<bidx, hr>(buf, &buf.x);
+        buf.x = src.x;
+        buf.y = src.y * (1.f / 255.f);
+        buf.z = src.z * (1.f / 255.f);
 
-            dst[0] = saturate_cast<uchar>(buf.x * 255.f);
-            dst[1] = saturate_cast<uchar>(buf.y * 255.f);
-            dst[2] = saturate_cast<uchar>(buf.z * 255.f);
-        }
-        template <int bidx, int hr> static __device__ uint HLS2RGBConvert(uint src)
-        {
-            float3 buf;
+        HLS2RGBConvert<bidx, hr>(buf, &buf.x);
 
-            buf.x = 0xff & src;
-            buf.y = (0xff & (src >> 8)) * (1.f / 255.f);
-            buf.z = (0xff & (src >> 16)) * (1.f / 255.f);
+        dst[0] = saturate_cast<uchar>(buf.x * 255.f);
+        dst[1] = saturate_cast<uchar>(buf.y * 255.f);
+        dst[2] = saturate_cast<uchar>(buf.z * 255.f);
+    }
+    template <int bidx, int hr> static __device__ uint HLS2RGBConvert(uint src)
+    {
+        float3 buf;
 
-            HLS2RGBConvert<bidx, hr>(buf, &buf.x);
+        buf.x = 0xff & src;
+        buf.y = (0xff & (src >> 8)) * (1.f / 255.f);
+        buf.z = (0xff & (src >> 16)) * (1.f / 255.f);
 
-            uint dst = 0xffu << 24;
+        HLS2RGBConvert<bidx, hr>(buf, &buf.x);
 
-            dst |= saturate_cast<uchar>(buf.x * 255.f);
-            dst |= saturate_cast<uchar>(buf.y * 255.f) << 8;
-            dst |= saturate_cast<uchar>(buf.z * 255.f) << 16;
+        uint dst = 0xffu << 24;
 
-            return dst;
-        }
+        dst |= saturate_cast<uchar>(buf.x * 255.f);
+        dst |= saturate_cast<uchar>(buf.y * 255.f) << 8;
+        dst |= saturate_cast<uchar>(buf.z * 255.f) << 16;
 
-        template <typename T, int scn, int dcn, int bidx, int hr> struct HLS2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+        return dst;
+    }
+
+    template <typename T, int scn, int dcn, int bidx, int hr> struct HLS2RGB : unary_function<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type>
+    {
+        __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
         {
-            __device__ __forceinline__ typename TypeVec<T, dcn>::vec_type operator()(const typename TypeVec<T, scn>::vec_type& src) const
-            {
-                typename TypeVec<T, dcn>::vec_type dst;
+            typename TypeVec<T, dcn>::vec_type dst;
 
-                HLS2RGBConvert<bidx, hr>(src, &dst.x);
-                setAlpha(dst, ColorChannel<T>::max());
+            HLS2RGBConvert<bidx, hr>(src, &dst.x);
+            setAlpha(dst, ColorChannel<T>::max());
 
-                return dst;
-            }
-        };
-        template <int bidx, int hr> struct HLS2RGB<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+            return dst;
+        }
+    };
+    template <int bidx, int hr> struct HLS2RGB<uchar, 4, 4, bidx, hr> : unary_function<uint, uint>
+    {
+        __device__ __forceinline__ uint operator()(uint src) const
         {
-            __device__ __forceinline__ uint operator()(uint src) const
-            {
-                return HLS2RGBConvert<bidx, hr>(src);
-            }
-        };
-    }
+            return HLS2RGBConvert<bidx, hr>(src);
+        }
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(name, scn, dcn, bidx) \
     template <typename T> struct name ## _traits \
@@ -1388,6 +1389,7 @@ namespace cv { namespace gpu { namespace device
             return functor_type(); \
         } \
     };
-}}}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_COLOR_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/transform_detail.hpp b/modules/gpu/src/opencv2/gpu/device/detail/transform_detail.hpp
index 212dcbcc2e02584de89fb5ad66974a7daad035a0..4e16be9b6f7d13453bcfa88bc51d5f497dfbc22b 100644
--- a/modules/gpu/src/opencv2/gpu/device/detail/transform_detail.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/detail/transform_detail.hpp
@@ -47,364 +47,365 @@
 #include "../vec_traits.hpp"
 #include "../functional.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace detail
 {
-    namespace detail
-    {
-        //! Mask accessor
+    //! Mask accessor
 
-        struct MaskReader
-        {
-            explicit MaskReader(const PtrStepb& mask_): mask(mask_) {}
+    struct MaskReader
+    {
+        explicit MaskReader(const PtrStepb& mask_): mask(mask_) {}
 
-            __device__ __forceinline__ bool operator()(int y, int x) const { return mask.ptr(y)[x]; }
+        __device__ __forceinline__ bool operator()(int y, int x) const { return mask.ptr(y)[x]; }
 
-            const PtrStepb mask;
-        };
+        const PtrStepb mask;
+    };
 
-        struct NoMask 
-        {
-            __device__ __forceinline__ bool operator()(int y, int x) const { return true; } 
-        };
+    struct NoMask 
+    {
+        __device__ __forceinline__ bool operator()(int y, int x) const { return true; } 
+    };
 
-        //! Read Write Traits
+    //! Read Write Traits
 
-        template <typename T, typename D, int shift> struct UnaryReadWriteTraits
-        {
-            typedef typename TypeVec<T, shift>::vec_type read_type;
-            typedef typename TypeVec<D, shift>::vec_type write_type;
-        };
+    template <typename T, typename D, int shift> struct UnaryReadWriteTraits
+    {
+        typedef typename TypeVec<T, shift>::vec_type read_type;
+        typedef typename TypeVec<D, shift>::vec_type write_type;
+    };
 
-        template <typename T1, typename T2, typename D, int shift> struct BinaryReadWriteTraits
-        {
-            typedef typename TypeVec<T1, shift>::vec_type read_type1;
-            typedef typename TypeVec<T2, shift>::vec_type read_type2;
-            typedef typename TypeVec<D, shift>::vec_type write_type;
-        };
+    template <typename T1, typename T2, typename D, int shift> struct BinaryReadWriteTraits
+    {
+        typedef typename TypeVec<T1, shift>::vec_type read_type1;
+        typedef typename TypeVec<T2, shift>::vec_type read_type2;
+        typedef typename TypeVec<D, shift>::vec_type write_type;
+    };
 
-        //! Transform kernels
+    //! Transform kernels
 
-        template <int shift> struct OpUnroller;
-        template <> struct OpUnroller<1>
+    template <int shift> struct OpUnroller;
+    template <> struct OpUnroller<1>
+    {
+        template <typename T, typename D, typename UnOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
         {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src.x);
-            }
+            if (mask(y, x_shifted))
+                dst.x = op(src.x);
+        }
 
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src1.x, src2.x);
-            }
-        };
-        template <> struct OpUnroller<2>
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
         {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src.x);
-                if (mask(y, x_shifted + 1))
-                    dst.y = op(src.y);
-            }
-
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src1.x, src2.x);
-                if (mask(y, x_shifted + 1))
-                    dst.y = op(src1.y, src2.y);
-            }
-        };
-        template <> struct OpUnroller<3>
+            if (mask(y, x_shifted))
+                dst.x = op(src1.x, src2.x);
+        }
+    };
+    template <> struct OpUnroller<2>
+    {
+        template <typename T, typename D, typename UnOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
         {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src.x);
-                if (mask(y, x_shifted + 1))
-                    dst.y = op(src.y);
-                if (mask(y, x_shifted + 2))
-                    dst.z = op(src.z);
-            }
+            if (mask(y, x_shifted))
+                dst.x = op(src.x);
+            if (mask(y, x_shifted + 1))
+                dst.y = op(src.y);
+        }
 
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src1.x, src2.x);
-                if (mask(y, x_shifted + 1))
-                    dst.y = op(src1.y, src2.y);
-                if (mask(y, x_shifted + 2))
-                    dst.z = op(src1.z, src2.z);
-            }
-        };
-        template <> struct OpUnroller<4>
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
         {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src.x);
-                if (mask(y, x_shifted + 1))
-                    dst.y = op(src.y);
-                if (mask(y, x_shifted + 2))
-                    dst.z = op(src.z);
-                if (mask(y, x_shifted + 3))
-                    dst.w = op(src.w);
-            }
-
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.x = op(src1.x, src2.x);
-                if (mask(y, x_shifted + 1))
-                    dst.y = op(src1.y, src2.y);
-                if (mask(y, x_shifted + 2))
-                    dst.z = op(src1.z, src2.z);
-                if (mask(y, x_shifted + 3))
-                    dst.w = op(src1.w, src2.w);
-            }
-        };
-        template <> struct OpUnroller<8>
+            if (mask(y, x_shifted))
+                dst.x = op(src1.x, src2.x);
+            if (mask(y, x_shifted + 1))
+                dst.y = op(src1.y, src2.y);
+        }
+    };
+    template <> struct OpUnroller<3>
+    {
+        template <typename T, typename D, typename UnOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
         {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.a0 = op(src.a0);
-                if (mask(y, x_shifted + 1))
-                    dst.a1 = op(src.a1);
-                if (mask(y, x_shifted + 2))
-                    dst.a2 = op(src.a2);
-                if (mask(y, x_shifted + 3))
-                    dst.a3 = op(src.a3);
-                if (mask(y, x_shifted + 4))
-                    dst.a4 = op(src.a4);
-                if (mask(y, x_shifted + 5))
-                    dst.a5 = op(src.a5);
-                if (mask(y, x_shifted + 6))
-                    dst.a6 = op(src.a6);
-                if (mask(y, x_shifted + 7))
-                    dst.a7 = op(src.a7);
-            }
-
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
-            {
-                if (mask(y, x_shifted))
-                    dst.a0 = op(src1.a0, src2.a0);
-                if (mask(y, x_shifted + 1))
-                    dst.a1 = op(src1.a1, src2.a1);
-                if (mask(y, x_shifted + 2))
-                    dst.a2 = op(src1.a2, src2.a2);
-                if (mask(y, x_shifted + 3))
-                    dst.a3 = op(src1.a3, src2.a3);
-                if (mask(y, x_shifted + 4))
-                    dst.a4 = op(src1.a4, src2.a4);
-                if (mask(y, x_shifted + 5))
-                    dst.a5 = op(src1.a5, src2.a5);
-                if (mask(y, x_shifted + 6))
-                    dst.a6 = op(src1.a6, src2.a6);
-                if (mask(y, x_shifted + 7))
-                    dst.a7 = op(src1.a7, src2.a7);
-            }
-        };
+            if (mask(y, x_shifted))
+                dst.x = op(src.x);
+            if (mask(y, x_shifted + 1))
+                dst.y = op(src.y);
+            if (mask(y, x_shifted + 2))
+                dst.z = op(src.z);
+        }
 
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
+        {
+            if (mask(y, x_shifted))
+                dst.x = op(src1.x, src2.x);
+            if (mask(y, x_shifted + 1))
+                dst.y = op(src1.y, src2.y);
+            if (mask(y, x_shifted + 2))
+                dst.z = op(src1.z, src2.z);
+        }
+    };
+    template <> struct OpUnroller<4>
+    {
         template <typename T, typename D, typename UnOp, typename Mask>
-        __global__ static void transformSmart(const DevMem2D_<T> src_, PtrStep<D> dst_, const Mask mask, const UnOp op)
+        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
         {
-            typedef TransformFunctorTraits<UnOp> ft;
-            typedef typename UnaryReadWriteTraits<T, D, ft::smart_shift>::read_type read_type;
-            typedef typename UnaryReadWriteTraits<T, D, ft::smart_shift>::write_type write_type;
-
-            const int x = threadIdx.x + blockIdx.x * blockDim.x;
-            const int y = threadIdx.y + blockIdx.y * blockDim.y;
-            const int x_shifted = x * ft::smart_shift;
-
-            if (y < src_.rows)
-            {
-                const T* src = src_.ptr(y);
-                D* dst = dst_.ptr(y);
-
-                if (x_shifted + ft::smart_shift - 1 < src_.cols)
-                {
-                    const read_type src_n_el = ((const read_type*)src)[x];
-                    write_type dst_n_el;
-
-                    OpUnroller<ft::smart_shift>::unroll(src_n_el, dst_n_el, mask, op, x_shifted, y);
-
-                    ((write_type*)dst)[x] = dst_n_el;
-                }
-                else
-                {
-                    for (int real_x = x_shifted; real_x < src_.cols; ++real_x)
-                    {
-                        if (mask(y, real_x))
-                            dst[real_x] = op(src[real_x]);
-                    }
-                }
-            }
+            if (mask(y, x_shifted))
+                dst.x = op(src.x);
+            if (mask(y, x_shifted + 1))
+                dst.y = op(src.y);
+            if (mask(y, x_shifted + 2))
+                dst.z = op(src.z);
+            if (mask(y, x_shifted + 3))
+                dst.w = op(src.w);
         }
 
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
+        {
+            if (mask(y, x_shifted))
+                dst.x = op(src1.x, src2.x);
+            if (mask(y, x_shifted + 1))
+                dst.y = op(src1.y, src2.y);
+            if (mask(y, x_shifted + 2))
+                dst.z = op(src1.z, src2.z);
+            if (mask(y, x_shifted + 3))
+                dst.w = op(src1.w, src2.w);
+        }
+    };
+    template <> struct OpUnroller<8>
+    {
         template <typename T, typename D, typename UnOp, typename Mask>
-        static __global__ void transformSimple(const DevMem2D_<T> src, PtrStep<D> dst, const Mask mask, const UnOp op)
+        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
         {
-		    const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		    const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-            if (x < src.cols && y < src.rows && mask(y, x))
-            {
-                dst.ptr(y)[x] = op(src.ptr(y)[x]);
-            }
+            if (mask(y, x_shifted))
+                dst.a0 = op(src.a0);
+            if (mask(y, x_shifted + 1))
+                dst.a1 = op(src.a1);
+            if (mask(y, x_shifted + 2))
+                dst.a2 = op(src.a2);
+            if (mask(y, x_shifted + 3))
+                dst.a3 = op(src.a3);
+            if (mask(y, x_shifted + 4))
+                dst.a4 = op(src.a4);
+            if (mask(y, x_shifted + 5))
+                dst.a5 = op(src.a5);
+            if (mask(y, x_shifted + 6))
+                dst.a6 = op(src.a6);
+            if (mask(y, x_shifted + 7))
+                dst.a7 = op(src.a7);
         }
 
         template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        __global__ static void transformSmart(const DevMem2D_<T1> src1_, const PtrStep<T2> src2_, PtrStep<D> dst_, 
-            const Mask mask, const BinOp op)
+        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
         {
-            typedef TransformFunctorTraits<BinOp> ft;
-            typedef typename BinaryReadWriteTraits<T1, T2, D, ft::smart_shift>::read_type1 read_type1;
-            typedef typename BinaryReadWriteTraits<T1, T2, D, ft::smart_shift>::read_type2 read_type2;
-            typedef typename BinaryReadWriteTraits<T1, T2, D, ft::smart_shift>::write_type write_type;
+            if (mask(y, x_shifted))
+                dst.a0 = op(src1.a0, src2.a0);
+            if (mask(y, x_shifted + 1))
+                dst.a1 = op(src1.a1, src2.a1);
+            if (mask(y, x_shifted + 2))
+                dst.a2 = op(src1.a2, src2.a2);
+            if (mask(y, x_shifted + 3))
+                dst.a3 = op(src1.a3, src2.a3);
+            if (mask(y, x_shifted + 4))
+                dst.a4 = op(src1.a4, src2.a4);
+            if (mask(y, x_shifted + 5))
+                dst.a5 = op(src1.a5, src2.a5);
+            if (mask(y, x_shifted + 6))
+                dst.a6 = op(src1.a6, src2.a6);
+            if (mask(y, x_shifted + 7))
+                dst.a7 = op(src1.a7, src2.a7);
+        }
+    };
 
-            const int x = threadIdx.x + blockIdx.x * blockDim.x;
-            const int y = threadIdx.y + blockIdx.y * blockDim.y;
-            const int x_shifted = x * ft::smart_shift;
+    template <typename T, typename D, typename UnOp, typename Mask>
+    __global__ static void transformSmart(const DevMem2D_<T> src_, PtrStep<D> dst_, const Mask mask, const UnOp op)
+    {
+        typedef TransformFunctorTraits<UnOp> ft;
+        typedef typename UnaryReadWriteTraits<T, D, ft::smart_shift>::read_type read_type;
+        typedef typename UnaryReadWriteTraits<T, D, ft::smart_shift>::write_type write_type;
+
+        const int x = threadIdx.x + blockIdx.x * blockDim.x;
+        const int y = threadIdx.y + blockIdx.y * blockDim.y;
+        const int x_shifted = x * ft::smart_shift;
+
+        if (y < src_.rows)
+        {
+            const T* src = src_.ptr(y);
+            D* dst = dst_.ptr(y);
 
-            if (y < src1_.rows)
+            if (x_shifted + ft::smart_shift - 1 < src_.cols)
             {
-                const T1* src1 = src1_.ptr(y);
-                const T2* src2 = src2_.ptr(y);
-                D* dst = dst_.ptr(y);
+                const read_type src_n_el = ((const read_type*)src)[x];
+                write_type dst_n_el;
 
-                if (x_shifted + ft::smart_shift - 1 < src1_.cols)
-                {
-                    const read_type1 src1_n_el = ((const read_type1*)src1)[x];
-                    const read_type2 src2_n_el = ((const read_type2*)src2)[x];
-                    write_type dst_n_el;
-                    
-                    OpUnroller<ft::smart_shift>::unroll(src1_n_el, src2_n_el, dst_n_el, mask, op, x_shifted, y);
+                OpUnroller<ft::smart_shift>::unroll(src_n_el, dst_n_el, mask, op, x_shifted, y);
 
-                    ((write_type*)dst)[x] = dst_n_el;
-                }
-                else
+                ((write_type*)dst)[x] = dst_n_el;
+            }
+            else
+            {
+                for (int real_x = x_shifted; real_x < src_.cols; ++real_x)
                 {
-                    for (int real_x = x_shifted; real_x < src1_.cols; ++real_x)
-                    {
-                        if (mask(y, real_x))
-                            dst[real_x] = op(src1[real_x], src2[real_x]);
-                    }
+                    if (mask(y, real_x))
+                        dst[real_x] = op(src[real_x]);
                 }
             }
         }
+    }
 
-        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static __global__ void transformSimple(const DevMem2D_<T1> src1, const PtrStep<T2> src2, PtrStep<D> dst, 
-            const Mask mask, const BinOp op)
-        {
-		    const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		    const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-            if (x < src1.cols && y < src1.rows && mask(y, x))
-            {
-                const T1 src1_data = src1.ptr(y)[x];
-                const T2 src2_data = src2.ptr(y)[x];
-                dst.ptr(y)[x] = op(src1_data, src2_data);
-            }
-        }
+    template <typename T, typename D, typename UnOp, typename Mask>
+    static __global__ void transformSimple(const DevMem2D_<T> src, PtrStep<D> dst, const Mask mask, const UnOp op)
+    {
+	    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+	    const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-        template <bool UseSmart> struct TransformDispatcher;
-        template<> struct TransformDispatcher<false>
+        if (x < src.cols && y < src.rows && mask(y, x))
         {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
-            {
-                typedef TransformFunctorTraits<UnOp> ft;
+            dst.ptr(y)[x] = op(src.ptr(y)[x]);
+        }
+    }
 
-                const dim3 threads(ft::simple_block_dim_x, ft::simple_block_dim_y, 1);
-                const dim3 grid(divUp(src.cols, threads.x), divUp(src.rows, threads.y), 1);     
+    template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+    __global__ static void transformSmart(const DevMem2D_<T1> src1_, const PtrStep<T2> src2_, PtrStep<D> dst_, 
+        const Mask mask, const BinOp op)
+    {
+        typedef TransformFunctorTraits<BinOp> ft;
+        typedef typename BinaryReadWriteTraits<T1, T2, D, ft::smart_shift>::read_type1 read_type1;
+        typedef typename BinaryReadWriteTraits<T1, T2, D, ft::smart_shift>::read_type2 read_type2;
+        typedef typename BinaryReadWriteTraits<T1, T2, D, ft::smart_shift>::write_type write_type;
 
-                transformSimple<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
+        const int x = threadIdx.x + blockIdx.x * blockDim.x;
+        const int y = threadIdx.y + blockIdx.y * blockDim.y;
+        const int x_shifted = x * ft::smart_shift;
 
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() ); 
-            }
+        if (y < src1_.rows)
+        {
+            const T1* src1 = src1_.ptr(y);
+            const T2* src2 = src2_.ptr(y);
+            D* dst = dst_.ptr(y);
 
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+            if (x_shifted + ft::smart_shift - 1 < src1_.cols)
             {
-                typedef TransformFunctorTraits<BinOp> ft;
-
-                const dim3 threads(ft::simple_block_dim_x, ft::simple_block_dim_y, 1);
-                const dim3 grid(divUp(src1.cols, threads.x), divUp(src1.rows, threads.y), 1);     
-
-                transformSimple<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
+                const read_type1 src1_n_el = ((const read_type1*)src1)[x];
+                const read_type2 src2_n_el = ((const read_type2*)src2)[x];
+                write_type dst_n_el;
+                
+                OpUnroller<ft::smart_shift>::unroll(src1_n_el, src2_n_el, dst_n_el, mask, op, x_shifted, y);
 
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() );            
+                ((write_type*)dst)[x] = dst_n_el;
             }
-        };
-        template<> struct TransformDispatcher<true>
-        {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+            else
             {
-                typedef TransformFunctorTraits<UnOp> ft;
+                for (int real_x = x_shifted; real_x < src1_.cols; ++real_x)
+                {
+                    if (mask(y, real_x))
+                        dst[real_x] = op(src1[real_x], src2[real_x]);
+                }
+            }
+        }
+    }
 
-                StaticAssert<ft::smart_shift != 1>::check();
+    template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+    static __global__ void transformSimple(const DevMem2D_<T1> src1, const PtrStep<T2> src2, PtrStep<D> dst, 
+        const Mask mask, const BinOp op)
+    {
+	    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+	    const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-                const dim3 threads(ft::smart_block_dim_x, ft::smart_block_dim_y, 1);
-                const dim3 grid(divUp(src.cols, threads.x * ft::smart_shift), divUp(src.rows, threads.y), 1);      
+        if (x < src1.cols && y < src1.rows && mask(y, x))
+        {
+            const T1 src1_data = src1.ptr(y)[x];
+            const T2 src2_data = src2.ptr(y)[x];
+            dst.ptr(y)[x] = op(src1_data, src2_data);
+        }
+    }
 
-                transformSmart<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
+    template <bool UseSmart> struct TransformDispatcher;
+    template<> struct TransformDispatcher<false>
+    {
+        template <typename T, typename D, typename UnOp, typename Mask>
+        static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+        {
+            typedef TransformFunctorTraits<UnOp> ft;
 
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() );
-            }
+            const dim3 threads(ft::simple_block_dim_x, ft::simple_block_dim_y, 1);
+            const dim3 grid(divUp(src.cols, threads.x), divUp(src.rows, threads.y), 1);     
 
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
-            {
-                typedef TransformFunctorTraits<BinOp> ft;
+            transformSimple<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
+            cudaSafeCall( cudaGetLastError() );
 
-                StaticAssert<ft::smart_shift != 1>::check();
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() ); 
+        }
 
-                const dim3 threads(ft::smart_block_dim_x, ft::smart_block_dim_y, 1);
-                const dim3 grid(divUp(src1.cols, threads.x * ft::smart_shift), divUp(src1.rows, threads.y), 1);    
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+        {
+            typedef TransformFunctorTraits<BinOp> ft;
 
-                transformSmart<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
+            const dim3 threads(ft::simple_block_dim_x, ft::simple_block_dim_y, 1);
+            const dim3 grid(divUp(src1.cols, threads.x), divUp(src1.rows, threads.y), 1);     
 
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() );            
-            }
-        };        
+            transformSimple<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
+            cudaSafeCall( cudaGetLastError() );
 
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );            
+        }
+    };
+    template<> struct TransformDispatcher<true>
+    {
         template <typename T, typename D, typename UnOp, typename Mask>
-        static void transform_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+        static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
         {
             typedef TransformFunctorTraits<UnOp> ft;
-            TransformDispatcher<VecTraits<T>::cn == 1 && VecTraits<D>::cn == 1 && ft::smart_shift != 1>::call(src, dst, op, mask, stream);
+
+            StaticAssert<ft::smart_shift != 1>::check();
+
+            const dim3 threads(ft::smart_block_dim_x, ft::smart_block_dim_y, 1);
+            const dim3 grid(divUp(src.cols, threads.x * ft::smart_shift), divUp(src.rows, threads.y), 1);      
+
+            transformSmart<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
+            cudaSafeCall( cudaGetLastError() );
+
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );
         }
 
         template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static void transform_caller(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+        static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
         {
             typedef TransformFunctorTraits<BinOp> ft;
-            TransformDispatcher<VecTraits<T1>::cn == 1 && VecTraits<T2>::cn == 1 && VecTraits<D>::cn == 1 && ft::smart_shift != 1>::call(src1, src2, dst, op, mask, stream);
+
+            StaticAssert<ft::smart_shift != 1>::check();
+
+            const dim3 threads(ft::smart_block_dim_x, ft::smart_block_dim_y, 1);
+            const dim3 grid(divUp(src1.cols, threads.x * ft::smart_shift), divUp(src1.rows, threads.y), 1);    
+
+            transformSmart<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
+            cudaSafeCall( cudaGetLastError() );
+
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );            
         }
+    };        
+
+    template <typename T, typename D, typename UnOp, typename Mask>
+    static void transform_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+    {
+        typedef TransformFunctorTraits<UnOp> ft;
+        TransformDispatcher<VecTraits<T>::cn == 1 && VecTraits<D>::cn == 1 && ft::smart_shift != 1>::call(src, dst, op, mask, stream);
     }
-}}}
+
+    template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+    static void transform_caller(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+    {
+        typedef TransformFunctorTraits<BinOp> ft;
+        TransformDispatcher<VecTraits<T1>::cn == 1 && VecTraits<T2>::cn == 1 && VecTraits<D>::cn == 1 && ft::smart_shift != 1>::call(src1, src2, dst, op, mask, stream);
+    }
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/type_traits_detail.hpp b/modules/gpu/src/opencv2/gpu/device/detail/type_traits_detail.hpp
index f6acce188726b22322ae6108b1a63fb4913efb78..f2eb82821456a35ff99fae58d7acadc05c4dcd79 100644
--- a/modules/gpu/src/opencv2/gpu/device/detail/type_traits_detail.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/detail/type_traits_detail.hpp
@@ -43,144 +43,146 @@
 #ifndef __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
 #define __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
 
+#include "internal_shared.hpp"
 #include "../vec_traits.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace detail
 {
-    namespace detail
-    {
-        template <bool, typename T1, typename T2> struct Select { typedef T1 type; };
-        template <typename T1, typename T2> struct Select<false, T1, T2> { typedef T2 type; };
+    template <bool, typename T1, typename T2> struct Select { typedef T1 type; };
+    template <typename T1, typename T2> struct Select<false, T1, T2> { typedef T2 type; };
 
-        template <typename T> struct IsSignedIntergral { enum {value = 0}; };
-        template <> struct IsSignedIntergral<schar> { enum {value = 1}; };
-        template <> struct IsSignedIntergral<char1> { enum {value = 1}; };
-        template <> struct IsSignedIntergral<short> { enum {value = 1}; };
-        template <> struct IsSignedIntergral<short1> { enum {value = 1}; };
-        template <> struct IsSignedIntergral<int> { enum {value = 1}; };
-        template <> struct IsSignedIntergral<int1> { enum {value = 1}; };
+    template <typename T> struct IsSignedIntergral { enum {value = 0}; };
+    template <> struct IsSignedIntergral<schar> { enum {value = 1}; };
+    template <> struct IsSignedIntergral<char1> { enum {value = 1}; };
+    template <> struct IsSignedIntergral<short> { enum {value = 1}; };
+    template <> struct IsSignedIntergral<short1> { enum {value = 1}; };
+    template <> struct IsSignedIntergral<int> { enum {value = 1}; };
+    template <> struct IsSignedIntergral<int1> { enum {value = 1}; };
 
-        template <typename T> struct IsUnsignedIntegral { enum {value = 0}; };
-        template <> struct IsUnsignedIntegral<uchar> { enum {value = 1}; };
-        template <> struct IsUnsignedIntegral<uchar1> { enum {value = 1}; };
-        template <> struct IsUnsignedIntegral<ushort> { enum {value = 1}; };
-        template <> struct IsUnsignedIntegral<ushort1> { enum {value = 1}; };
-        template <> struct IsUnsignedIntegral<uint> { enum {value = 1}; };
-        template <> struct IsUnsignedIntegral<uint1> { enum {value = 1}; };
+    template <typename T> struct IsUnsignedIntegral { enum {value = 0}; };
+    template <> struct IsUnsignedIntegral<uchar> { enum {value = 1}; };
+    template <> struct IsUnsignedIntegral<uchar1> { enum {value = 1}; };
+    template <> struct IsUnsignedIntegral<ushort> { enum {value = 1}; };
+    template <> struct IsUnsignedIntegral<ushort1> { enum {value = 1}; };
+    template <> struct IsUnsignedIntegral<uint> { enum {value = 1}; };
+    template <> struct IsUnsignedIntegral<uint1> { enum {value = 1}; };
 
-        template <typename T> struct IsIntegral { enum {value = IsSignedIntergral<T>::value || IsUnsignedIntegral<T>::value}; };
-        template <> struct IsIntegral<char> { enum {value = 1}; };
-        template <> struct IsIntegral<bool> { enum {value = 1}; };
+    template <typename T> struct IsIntegral { enum {value = IsSignedIntergral<T>::value || IsUnsignedIntegral<T>::value}; };
+    template <> struct IsIntegral<char> { enum {value = 1}; };
+    template <> struct IsIntegral<bool> { enum {value = 1}; };
 
-        template <typename T> struct IsFloat { enum {value = 0}; };
-        template <> struct IsFloat<float> { enum {value = 1}; };
-        template <> struct IsFloat<double> { enum {value = 1}; };
+    template <typename T> struct IsFloat { enum {value = 0}; };
+    template <> struct IsFloat<float> { enum {value = 1}; };
+    template <> struct IsFloat<double> { enum {value = 1}; };
 
-        template <typename T> struct IsVec { enum {value = 0}; };
-        template <> struct IsVec<uchar1> { enum {value = 1}; };
-        template <> struct IsVec<uchar2> { enum {value = 1}; };
-        template <> struct IsVec<uchar3> { enum {value = 1}; };
-        template <> struct IsVec<uchar4> { enum {value = 1}; };
-        template <> struct IsVec<uchar8> { enum {value = 1}; };
-        template <> struct IsVec<char1> { enum {value = 1}; };
-        template <> struct IsVec<char2> { enum {value = 1}; };
-        template <> struct IsVec<char3> { enum {value = 1}; };
-        template <> struct IsVec<char4> { enum {value = 1}; };
-        template <> struct IsVec<char8> { enum {value = 1}; };
-        template <> struct IsVec<ushort1> { enum {value = 1}; };
-        template <> struct IsVec<ushort2> { enum {value = 1}; };
-        template <> struct IsVec<ushort3> { enum {value = 1}; };
-        template <> struct IsVec<ushort4> { enum {value = 1}; };
-        template <> struct IsVec<ushort8> { enum {value = 1}; };
-        template <> struct IsVec<short1> { enum {value = 1}; };
-        template <> struct IsVec<short2> { enum {value = 1}; };
-        template <> struct IsVec<short3> { enum {value = 1}; };
-        template <> struct IsVec<short4> { enum {value = 1}; };
-        template <> struct IsVec<short8> { enum {value = 1}; };
-        template <> struct IsVec<uint1> { enum {value = 1}; };
-        template <> struct IsVec<uint2> { enum {value = 1}; };
-        template <> struct IsVec<uint3> { enum {value = 1}; };
-        template <> struct IsVec<uint4> { enum {value = 1}; };
-        template <> struct IsVec<uint8> { enum {value = 1}; };
-        template <> struct IsVec<int1> { enum {value = 1}; };
-        template <> struct IsVec<int2> { enum {value = 1}; };
-        template <> struct IsVec<int3> { enum {value = 1}; };
-        template <> struct IsVec<int4> { enum {value = 1}; };
-        template <> struct IsVec<int8> { enum {value = 1}; };
-        template <> struct IsVec<float1> { enum {value = 1}; };
-        template <> struct IsVec<float2> { enum {value = 1}; };
-        template <> struct IsVec<float3> { enum {value = 1}; };
-        template <> struct IsVec<float4> { enum {value = 1}; };
-        template <> struct IsVec<float8> { enum {value = 1}; };
-        template <> struct IsVec<double1> { enum {value = 1}; };
-        template <> struct IsVec<double2> { enum {value = 1}; };
-        template <> struct IsVec<double3> { enum {value = 1}; };
-        template <> struct IsVec<double4> { enum {value = 1}; };
-        template <> struct IsVec<double8> { enum {value = 1}; };
+    template <typename T> struct IsVec { enum {value = 0}; };
+    template <> struct IsVec<uchar1> { enum {value = 1}; };
+    template <> struct IsVec<uchar2> { enum {value = 1}; };
+    template <> struct IsVec<uchar3> { enum {value = 1}; };
+    template <> struct IsVec<uchar4> { enum {value = 1}; };
+    template <> struct IsVec<uchar8> { enum {value = 1}; };
+    template <> struct IsVec<char1> { enum {value = 1}; };
+    template <> struct IsVec<char2> { enum {value = 1}; };
+    template <> struct IsVec<char3> { enum {value = 1}; };
+    template <> struct IsVec<char4> { enum {value = 1}; };
+    template <> struct IsVec<char8> { enum {value = 1}; };
+    template <> struct IsVec<ushort1> { enum {value = 1}; };
+    template <> struct IsVec<ushort2> { enum {value = 1}; };
+    template <> struct IsVec<ushort3> { enum {value = 1}; };
+    template <> struct IsVec<ushort4> { enum {value = 1}; };
+    template <> struct IsVec<ushort8> { enum {value = 1}; };
+    template <> struct IsVec<short1> { enum {value = 1}; };
+    template <> struct IsVec<short2> { enum {value = 1}; };
+    template <> struct IsVec<short3> { enum {value = 1}; };
+    template <> struct IsVec<short4> { enum {value = 1}; };
+    template <> struct IsVec<short8> { enum {value = 1}; };
+    template <> struct IsVec<uint1> { enum {value = 1}; };
+    template <> struct IsVec<uint2> { enum {value = 1}; };
+    template <> struct IsVec<uint3> { enum {value = 1}; };
+    template <> struct IsVec<uint4> { enum {value = 1}; };
+    template <> struct IsVec<uint8> { enum {value = 1}; };
+    template <> struct IsVec<int1> { enum {value = 1}; };
+    template <> struct IsVec<int2> { enum {value = 1}; };
+    template <> struct IsVec<int3> { enum {value = 1}; };
+    template <> struct IsVec<int4> { enum {value = 1}; };
+    template <> struct IsVec<int8> { enum {value = 1}; };
+    template <> struct IsVec<float1> { enum {value = 1}; };
+    template <> struct IsVec<float2> { enum {value = 1}; };
+    template <> struct IsVec<float3> { enum {value = 1}; };
+    template <> struct IsVec<float4> { enum {value = 1}; };
+    template <> struct IsVec<float8> { enum {value = 1}; };
+    template <> struct IsVec<double1> { enum {value = 1}; };
+    template <> struct IsVec<double2> { enum {value = 1}; };
+    template <> struct IsVec<double3> { enum {value = 1}; };
+    template <> struct IsVec<double4> { enum {value = 1}; };
+    template <> struct IsVec<double8> { enum {value = 1}; };
 
-        template <class U> struct AddParameterType { typedef const U& type; };
-        template <class U> struct AddParameterType<U&> { typedef U& type; };
-        template <> struct AddParameterType<void> { typedef void type; };
+    template <class U> struct AddParameterType { typedef const U& type; };
+    template <class U> struct AddParameterType<U&> { typedef U& type; };
+    template <> struct AddParameterType<void> { typedef void type; };
+
+    template <class U> struct ReferenceTraits 
+    {
+        enum { value = false };
+        typedef U type;
+    };        
+    template <class U> struct ReferenceTraits<U&>
+    {
+        enum { value = true };
+        typedef U type;
+    };
+           
+    template <class U> struct PointerTraits
+    {
+        enum { value = false };
+        typedef void type;
+    };        
+    template <class U> struct PointerTraits<U*>
+    {
+        enum { value = true };
+        typedef U type;
+    };        
+    template <class U> struct PointerTraits<U*&>
+    {
+        enum { value = true };
+        typedef U type;
+    };
+     
+    template <class U> struct UnConst
+    {
+        typedef U type;
+        enum { value = 0 };
+    };        
+    template <class U> struct UnConst<const U>
+    {
+        typedef U type;
+        enum { value = 1 };
+    };
+    template <class U> struct UnConst<const U&>
+    {
+        typedef U& type;
+        enum { value = 1 };
+    };
 
-        template <class U> struct ReferenceTraits 
-        {
-            enum { value = false };
-            typedef U type;
-        };        
-        template <class U> struct ReferenceTraits<U&>
-        {
-            enum { value = true };
-            typedef U type;
-        };
-               
-        template <class U> struct PointerTraits
-        {
-            enum { value = false };
-            typedef void type;
-        };        
-        template <class U> struct PointerTraits<U*>
-        {
-            enum { value = true };
-            typedef U type;
-        };        
-        template <class U> struct PointerTraits<U*&>
-        {
-            enum { value = true };
-            typedef U type;
-        };
-         
-        template <class U> struct UnConst
-        {
-            typedef U type;
-            enum { value = 0 };
-        };        
-        template <class U> struct UnConst<const U>
-        {
-            typedef U type;
-            enum { value = 1 };
-        };
-        template <class U> struct UnConst<const U&>
-        {
-            typedef U& type;
-            enum { value = 1 };
-        };
+    template <class U> struct UnVolatile
+    {
+        typedef U type;
+        enum { value = 0 };
+    };       
+    template <class U> struct UnVolatile<volatile U>
+    {
+        typedef U type;
+        enum { value = 1 };
+    };
+    template <class U> struct UnVolatile<volatile U&>
+    {
+        typedef U& type;
+        enum { value = 1 };
+    };
+}
 
-        template <class U> struct UnVolatile
-        {
-            typedef U type;
-            enum { value = 0 };
-        };       
-        template <class U> struct UnVolatile<volatile U>
-        {
-            typedef U type;
-            enum { value = 1 };
-        };
-        template <class U> struct UnVolatile<volatile U&>
-        {
-            typedef U& type;
-            enum { value = 1 };
-        };
-    }
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/utility_detail.hpp b/modules/gpu/src/opencv2/gpu/device/detail/utility_detail.hpp
index e7666627f73e4470f998d13c0a906c08d299addd..2818c285284806f665dd7f4095b543bb7a09670b 100644
--- a/modules/gpu/src/opencv2/gpu/device/detail/utility_detail.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/detail/utility_detail.hpp
@@ -43,225 +43,462 @@
 #ifndef __OPENCV_GPU_UTILITY_DETAIL_HPP__
 #define __OPENCV_GPU_UTILITY_DETAIL_HPP__
 
-namespace cv { namespace gpu { namespace device
+#include "internal_shared.hpp"
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace detail
 {
-    namespace detail
-    {
-        ///////////////////////////////////////////////////////////////////////////////
-        // Reduction
+    ///////////////////////////////////////////////////////////////////////////////
+    // Reduction
 
-        template <int n> struct WarpReductor
+    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)
         {
-            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 (tid < n)
+                data[tid] = partial_reduction;                
+            if (n > 32) __syncthreads();
 
-                if (n > 32)
+            if (n > 32)
+            {
+                if (tid < n - 32) 
+                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 32]);
+                if (tid < 16)
                 {
-                    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]);
-                    }
+                    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)
+            }
+            else if (n > 16)
+            {
+                if (tid < n - 16) 
+                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
+                if (tid < 8)
                 {
-                    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]);
-                    }
+                    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)
+            }
+            else if (n > 8)
+            {
+                if (tid < n - 8) 
+                    data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
+                if (tid < 4)
                 {
-                    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]);
-                    }
+                    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)
+            }
+            else if (n > 4)
+            {
+                if (tid < n - 4) 
+                    data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
+                if (tid < 2)
                 {
-                    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)
+                    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)
                 {
-                    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]);
-                    }
-                }      
+                    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<64>
+        }
+    };
+    template <> struct WarpReductor<32>
+    {
+        template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
         {
-            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;
-                __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 ]); 
-                }
+                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 <> struct WarpReductor<16>
+    {
+        template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
         {
-            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;
-                
-                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 ]); 
-                }
+                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 <> struct WarpReductor<8>
+    {
+        template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
         {
-            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;
-                
-                if (tid < 8) 
+            __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))
                 {
-                    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 ]); 
+                    sdata[tid] = myData = reg;
+                    sval[tid] = myVal = sval[tid + 1];
                 }
             }
-        };
-        template <> struct WarpReductor<8>
+        }
+    };
+    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)
         {
-            template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+            if (tid < 16)
             {
-                data[tid] = partial_reduction;
-                
-                if (tid < 4) 
+                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))
                 {
-                    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 ]); 
+                    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 ReductionDispatcher;
-        template <> struct ReductionDispatcher<true>
+    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)
         {
-            template <int n, typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+            if (tid < 8)
             {
-                WarpReductor<n>::reduce(data, partial_reduction, tid, op);
+                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 ReductionDispatcher<false>
+        }
+    };
+    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)
         {
-            template <int n, typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+            if (tid < 4)
             {
-                if (tid < n)
-                    data[tid] = partial_reduction;
-                __syncthreads();
+                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) { 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 (n >= 512 && tid < 256) 
+            {
+                T reg = sdata[tid + 256];
 
-                if (tid < 32)
+                if (pred(reg, myData))
                 {
-                    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]);
+                    sdata[tid] = myData = reg;
+                    sval[tid] = myVal = sval[tid + 256];
                 }
+                __syncthreads(); 
             }
-        };
+            if (n >= 256 && tid < 128) 
+            {
+                T reg = sdata[tid + 128];
 
-        ///////////////////////////////////////////////////////////////////////////////
-        // 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 (pred(reg, myData))
+                {
+                    sdata[tid] = myData = reg;
+                    sval[tid] = myVal = sval[tid + 128];
+                }
+                __syncthreads(); 
+            }
+            if (n >= 128 && tid < 64) 
             {
-                if (tid < 32)
+                T reg = sdata[tid + 64];
+
+                if (pred(reg, myData))
                 {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
+                    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];
 
-                    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];
 
-                    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];
 
-                    reg = sdata[tid + 4];
                     if (pred(reg, myData))
                     {
                         sdata[tid] = myData = reg;
                         sval[tid] = myVal = sval[tid + 4];
                     }
-                
-                    reg = sdata[tid + 2];
+                }
+                if (n >= 4) 
+                { 
+                    T reg = sdata[tid + 2];
+
                     if (pred(reg, myData))
                     {
                         sdata[tid] = myData = reg;
                         sval[tid] = myVal = sval[tid + 2];
-                    }
-                
-                    reg = sdata[tid + 1];
+                    } 
+                }
+                if (n >= 2) 
+                { 
+                    T reg = sdata[tid + 1];
+
                     if (pred(reg, myData))
                     {
                         sdata[tid] = myData = reg;
@@ -269,436 +506,327 @@ namespace cv { namespace gpu { namespace device
                     }
                 }
             }
-        };
-        template <> struct PredValWarpReductor<32>
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // 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)
         {
-            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)
             {
-                if (tid < 16)
+                myData = sdata[tid];
+                myVal1 = sval1[tid];
+                myVal2 = sval2[tid];
+
+                T reg = sdata[tid + 32];
+                if (pred(reg, myData))
                 {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 32];
+                    sval2[tid] = myVal2 = sval2[tid + 32];
+                }
 
-                    T reg = sdata[tid + 16];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 16];
-                    }
+                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;
-                        sval[tid] = myVal = sval[tid + 8];
-                    }
+                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;
-                        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];
-                    }
+                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 PredValWarpReductor<16>
+        }
+    };
+    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)
         {
-            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)
             {
-                if (tid < 8)
+                myData = sdata[tid];
+                myVal1 = sval1[tid];
+                myVal2 = sval2[tid];
+
+                T reg = sdata[tid + 16];
+                if (pred(reg, myData))
                 {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 16];
+                    sval2[tid] = myVal2 = sval2[tid + 16];
+                }
 
-                    T reg = reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 8];
-                    }
+                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;
-                        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];
-                    }
+                reg = sdata[tid + 4];
+                if (pred(reg, myData))
+                {
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 4];
+                    sval2[tid] = myVal2 = sval2[tid + 4];
                 }
-            }
-        };
-        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)
+            
+                reg = sdata[tid + 2];
+                if (pred(reg, myData))
                 {
-                    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];
-                    }
+                    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 PredValReductionDispatcher;
-        template <> struct PredValReductionDispatcher<true>
+    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)
         {
-            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)
+            if (tid < 8)
             {
-                PredValWarpReductor<n>::reduce(myData, myVal, sdata, sval, tid, pred);
+                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 PredValReductionDispatcher<false>
+        }
+    };
+    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)
         {
-            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)
+            if (tid < 4)
             {
                 myData = sdata[tid];
-                myVal = sval[tid];
+                myVal1 = sval1[tid];
+                myVal2 = sval2[tid];
 
-                if (n >= 512 && tid < 256) 
+                T reg = reg = sdata[tid + 4];
+                if (pred(reg, myData))
                 {
-                    T reg = sdata[tid + 256];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 256];
-                    }
-                    __syncthreads(); 
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 4];
+                    sval2[tid] = myVal2 = sval2[tid + 4];
                 }
-                if (n >= 256 && tid < 128) 
+            
+                reg = sdata[tid + 2];
+                if (pred(reg, myData))
                 {
-                    T reg = sdata[tid + 128];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 128];
-                    }
-                    __syncthreads(); 
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 2];
+                    sval2[tid] = myVal2 = sval2[tid + 2];
                 }
-                if (n >= 128 && tid < 64) 
+            
+                reg = sdata[tid + 1];
+                if (pred(reg, myData))
                 {
-                    T reg = sdata[tid + 64];
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 1];
+                    sval2[tid] = myVal2 = sval2[tid + 1];
+                }
+            }
+        }
+    };
 
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 64];
-                    }
-                    __syncthreads(); 
-                }        
+    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 (tid < 32)
-                {
-                    if (n >= 64) 
-                    { 
-                        T reg = sdata[tid + 32];
+            if (n >= 512 && tid < 256) 
+            {
+                T reg = sdata[tid + 256];
 
-                        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];
-                        }
-                    }
+                if (pred(reg, myData))
+                {
+                    sdata[tid] = myData = reg;
+                    sval1[tid] = myVal1 = sval1[tid + 256];
+                    sval2[tid] = myVal2 = sval2[tid + 256];
                 }
+                __syncthreads(); 
             }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // PredVal2WarpReductor
+            if (n >= 256 && tid < 128) 
+            {
+                T reg = sdata[tid + 128];
 
-        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 (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) 
             {
-                if (tid < 32)
+                T reg = sdata[tid + 64];
+
+                if (pred(reg, myData))
                 {
-                    myData = sdata[tid];
-                    myVal1 = sval1[tid];
-                    myVal2 = sval2[tid];
+                    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];
                     }
-
-                    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];
-
+                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];
 
-                    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];
 
-                    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];
-                    }
+                if (n >= 4) 
+                { 
+                    T reg = sdata[tid + 2];
 
-                    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];
+                if (n >= 2) 
+                { 
+                    T reg = sdata[tid + 1];
 
-                    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;
@@ -707,135 +835,10 @@ namespace cv { namespace gpu { namespace device
                     }
                 }
             }
-        };
-
-        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];
-                        }
-                    }
-                }
-            }
-        };
-    }
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_UTILITY_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/vec_distance_detail.hpp b/modules/gpu/src/opencv2/gpu/device/detail/vec_distance_detail.hpp
index 5171654fe343bba2b70c5220ba2615275aa715f2..b27fd7572fd8e46144e3c6bbf3dffcc1536744c2 100644
--- a/modules/gpu/src/opencv2/gpu/device/detail/vec_distance_detail.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/detail/vec_distance_detail.hpp
@@ -43,75 +43,77 @@
 #ifndef __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
 #define __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
 
+#include "internal_shared.hpp"
 #include "../datamov_utils.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace detail
 {
-    namespace detail
+    template <int THREAD_DIM, int N> struct UnrollVecDiffCached
     {
-        template <int THREAD_DIM, int N> struct UnrollVecDiffCached
+        template <typename Dist, typename T1, typename T2>
+        static __device__ void calcCheck(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, int ind)
         {
-            template <typename Dist, typename T1, typename T2>
-            static __device__ void calcCheck(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, int ind)
+            if (ind < len)
             {
-                if (ind < len)
-                {
-                    T1 val1 = *vecCached++;
+                T1 val1 = *vecCached++;
 
-                    T2 val2;
-                    ForceGlob<T2>::Load(vecGlob, ind, val2);
+                T2 val2;
+                ForceGlob<T2>::Load(vecGlob, ind, val2);
 
-                    dist.reduceIter(val1, val2);
+                dist.reduceIter(val1, val2);
 
-                    UnrollVecDiffCached<THREAD_DIM, N - 1>::calcCheck(vecCached, vecGlob, len, dist, ind + THREAD_DIM);
-                }
+                UnrollVecDiffCached<THREAD_DIM, N - 1>::calcCheck(vecCached, vecGlob, len, dist, ind + THREAD_DIM);
             }
+        }
 
-            template <typename Dist, typename T1, typename T2>
-            static __device__ void calcWithoutCheck(const T1* vecCached, const T2* vecGlob, Dist& dist)
-            {
-                T1 val1 = *vecCached++;
+        template <typename Dist, typename T1, typename T2>
+        static __device__ void calcWithoutCheck(const T1* vecCached, const T2* vecGlob, Dist& dist)
+        {
+            T1 val1 = *vecCached++;
 
-                T2 val2;
-                ForceGlob<T2>::Load(vecGlob, 0, val2);
-                vecGlob += THREAD_DIM;
+            T2 val2;
+            ForceGlob<T2>::Load(vecGlob, 0, val2);
+            vecGlob += THREAD_DIM;
 
-                dist.reduceIter(val1, val2);
+            dist.reduceIter(val1, val2);
 
-                UnrollVecDiffCached<THREAD_DIM, N - 1>::calcWithoutCheck(vecCached, vecGlob, dist);
-            }
-        };
-        template <int THREAD_DIM> struct UnrollVecDiffCached<THREAD_DIM, 0>
+            UnrollVecDiffCached<THREAD_DIM, N - 1>::calcWithoutCheck(vecCached, vecGlob, dist);
+        }
+    };
+    template <int THREAD_DIM> struct UnrollVecDiffCached<THREAD_DIM, 0>
+    {
+        template <typename Dist, typename T1, typename T2>
+        static __device__ __forceinline__ void calcCheck(const T1*, const T2*, int, Dist&, int)
         {
-            template <typename Dist, typename T1, typename T2>
-            static __device__ __forceinline__ void calcCheck(const T1*, const T2*, int, Dist&, int)
-            {
-            }
+        }
 
-            template <typename Dist, typename T1, typename T2>
-            static __device__ __forceinline__ void calcWithoutCheck(const T1*, const T2*, Dist&)
-            {
-            }
-        };
+        template <typename Dist, typename T1, typename T2>
+        static __device__ __forceinline__ void calcWithoutCheck(const T1*, const T2*, Dist&)
+        {
+        }
+    };
 
-        template <int THREAD_DIM, int MAX_LEN, bool LEN_EQ_MAX_LEN> struct VecDiffCachedCalculator;
-        template <int THREAD_DIM, int MAX_LEN> struct VecDiffCachedCalculator<THREAD_DIM, MAX_LEN, false>
+    template <int THREAD_DIM, int MAX_LEN, bool LEN_EQ_MAX_LEN> struct VecDiffCachedCalculator;
+    template <int THREAD_DIM, int MAX_LEN> struct VecDiffCachedCalculator<THREAD_DIM, MAX_LEN, false>
+    {
+        template <typename Dist, typename T1, typename T2>
+        static __device__ __forceinline__ void calc(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, int tid)
         {
-            template <typename Dist, typename T1, typename T2>
-            static __device__ __forceinline__ void calc(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, int tid)
-            {
-                UnrollVecDiffCached<THREAD_DIM, MAX_LEN / THREAD_DIM>::calcCheck(vecCached, vecGlob, len, dist, tid);
-            }
-        };
-        template <int THREAD_DIM, int MAX_LEN> struct VecDiffCachedCalculator<THREAD_DIM, MAX_LEN, true>
+            UnrollVecDiffCached<THREAD_DIM, MAX_LEN / THREAD_DIM>::calcCheck(vecCached, vecGlob, len, dist, tid);
+        }
+    };
+    template <int THREAD_DIM, int MAX_LEN> struct VecDiffCachedCalculator<THREAD_DIM, MAX_LEN, true>
+    {
+        template <typename Dist, typename T1, typename T2>
+        static __device__ __forceinline__ void calc(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, int tid)
         {
-            template <typename Dist, typename T1, typename T2>
-            static __device__ __forceinline__ void calc(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, int tid)
-            {
-                UnrollVecDiffCached<THREAD_DIM, MAX_LEN / THREAD_DIM>::calcWithoutCheck(vecCached, vecGlob + tid, dist);
-            }
-        };
-    }
-}}}
+            UnrollVecDiffCached<THREAD_DIM, MAX_LEN / THREAD_DIM>::calcWithoutCheck(vecCached, vecGlob + tid, dist);
+        }
+    };
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/dynamic_smem.hpp b/modules/gpu/src/opencv2/gpu/device/dynamic_smem.hpp
index 7ce6994fd7dccc4e2f6c42638dae2cc80b279d55..5d1308ae4e08ef8f14b5e0b12a42ac70f7254ad4 100644
--- a/modules/gpu/src/opencv2/gpu/device/dynamic_smem.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/dynamic_smem.hpp
@@ -43,38 +43,41 @@
 #ifndef __OPENCV_GPU_DYNAMIC_SMEM_HPP__
 #define __OPENCV_GPU_DYNAMIC_SMEM_HPP__
 
-namespace cv { namespace gpu { namespace device
-{   
-    template<class T> struct DynamicSharedMem
+#include "internal_shared.hpp"
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+   
+template<class T> struct DynamicSharedMem
+{
+    __device__ __forceinline__ operator T*()
+    {
+        extern __shared__ int __smem[];
+        return (T*)__smem;
+    }
+
+    __device__ __forceinline__ operator const T*() const
     {
-        __device__ __forceinline__ operator T*()
-        {
-            extern __shared__ int __smem[];
-            return (T*)__smem;
-        }
+        extern __shared__ int __smem[];
+        return (T*)__smem;
+    }
+};
 
-        __device__ __forceinline__ operator const T*() const
-        {
-            extern __shared__ int __smem[];
-            return (T*)__smem;
-        }
-    };
+// specialize for double to avoid unaligned memory access compile errors
+template<> struct DynamicSharedMem<double>
+{
+    __device__ __forceinline__ operator double*()
+    {
+        extern __shared__ double __smem_d[];
+        return (double*)__smem_d;
+    }
 
-    // specialize for double to avoid unaligned memory access compile errors
-    template<> struct DynamicSharedMem<double>
+    __device__ __forceinline__ operator const double*() const
     {
-        __device__ __forceinline__ operator double*()
-        {
-            extern __shared__ double __smem_d[];
-            return (double*)__smem_d;
-        }
+        extern __shared__ double __smem_d[];
+        return (double*)__smem_d;
+    }
+};
 
-        __device__ __forceinline__ operator const double*() const
-        {
-            extern __shared__ double __smem_d[];
-            return (double*)__smem_d;
-        }
-    };
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_DYNAMIC_SMEM_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/emulation.hpp b/modules/gpu/src/opencv2/gpu/device/emulation.hpp
index f9c8d81cf5232e25a9cd901faf9ab6d3762e7a66..7220c81e1bdf4dda919943d7344ae7731a6cebf0 100644
--- a/modules/gpu/src/opencv2/gpu/device/emulation.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/emulation.hpp
@@ -43,27 +43,26 @@
 #ifndef OPENCV_GPU_EMULATION_HPP_
 #define OPENCV_GPU_EMULATION_HPP_
 
-#include "opencv2/gpu/device/warp_reduce.hpp"
+#include "internal_shared.hpp"
+#include "warp_reduce.hpp"
 
-namespace cv
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+struct Emulation
 {
-	namespace device
+	static __forceinline__ __device__ int Ballot(int predicate, volatile int* cta_buffer)
 	{
-		struct Emulation
-		{
-			static __forceinline__ __device__ int Ballot(int predicate, volatile int* cta_buffer)
-			{
 #if __CUDA_ARCH__ >= 200
-				(void)cta_buffer;
-				return __ballot(predicate);
+		(void)cta_buffer;
+		return __ballot(predicate);
 #else
-				int tid = threadIdx.x;				
-				cta_buffer[tid] = predicate ? (1 << (tid & 31)) : 0;
-				return warp_reduce(cta_buffer);
+		int tid = threadIdx.x;				
+		cta_buffer[tid] = predicate ? (1 << (tid & 31)) : 0;
+		return warp_reduce(cta_buffer);
 #endif
-			}
-		};
 	}
-}
+};
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif /* OPENCV_GPU_EMULATION_HPP_ */
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/filters.hpp b/modules/gpu/src/opencv2/gpu/device/filters.hpp
index 2f8d012117e52d5f44730100d77d9ff85efd11f4..5c54bd960a61d66641bdbb794fcb51001cb5fa15 100644
--- a/modules/gpu/src/opencv2/gpu/device/filters.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/filters.hpp
@@ -43,93 +43,95 @@
 #ifndef __OPENCV_GPU_FILTERS_HPP__
 #define __OPENCV_GPU_FILTERS_HPP__
 
+#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "vec_traits.hpp"
 #include "vec_math.hpp"
 
-namespace cv {  namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename Ptr2D> struct PointFilter
 {
-    template <typename Ptr2D> struct PointFilter
+    typedef typename Ptr2D::elem_type elem_type;
+    typedef float index_type;
+
+    explicit __host__ __device__ __forceinline__ PointFilter(const Ptr2D& src_) : src(src_) {}
+     
+    __device__ __forceinline__ elem_type operator ()(float y, float x) const
     {
-        typedef typename Ptr2D::elem_type elem_type;
-        typedef float index_type;
+        return src(__float2int_rn(y), __float2int_rn(x));
+    }
+
+    const Ptr2D src;
+};
 
-        explicit __host__ __device__ __forceinline__ PointFilter(const Ptr2D& src_) : src(src_) {}
-         
-        __device__ __forceinline__ elem_type operator ()(float y, float x) const
-        {
-            return src(__float2int_rn(y), __float2int_rn(x));
-        }
+template <typename Ptr2D> struct LinearFilter
+{
+    typedef typename Ptr2D::elem_type elem_type;
+    typedef float index_type;
 
-        const Ptr2D src;
-    };
+    explicit __host__ __device__ __forceinline__ LinearFilter(const Ptr2D& src_) : src(src_) {}
 
-    template <typename Ptr2D> struct LinearFilter
+    __device__ __forceinline__ elem_type operator ()(float y, float x) const
     {
-        typedef typename Ptr2D::elem_type elem_type;
-        typedef float index_type;
+        typedef typename TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;
 
-        explicit __host__ __device__ __forceinline__ LinearFilter(const Ptr2D& src_) : src(src_) {}
+        work_type out = VecTraits<work_type>::all(0);
 
-        __device__ __forceinline__ elem_type operator ()(float y, float x) const
-        {
-            typedef typename TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;
+        const int x1 = __float2int_rd(x);
+        const int y1 = __float2int_rd(y);
+        const int x2 = x1 + 1;
+        const int y2 = y1 + 1;
 
-            work_type out = VecTraits<work_type>::all(0);
+        elem_type src_reg = src(y1, x1);
+        out = out + src_reg * ((x2 - x) * (y2 - y));
 
-            const int x1 = __float2int_rd(x);
-            const int y1 = __float2int_rd(y);
-            const int x2 = x1 + 1;
-            const int y2 = y1 + 1;
+        src_reg = src(y1, x2);
+        out = out + src_reg * ((x - x1) * (y2 - y));
 
-            elem_type src_reg = src(y1, x1);
-            out = out + src_reg * ((x2 - x) * (y2 - y));
+        src_reg = src(y2, x1);
+        out = out + src_reg * ((x2 - x) * (y - y1));
 
-            src_reg = src(y1, x2);
-            out = out + src_reg * ((x - x1) * (y2 - y));
+        src_reg = src(y2, x2);
+        out = out + src_reg * ((x - x1) * (y - y1));
 
-            src_reg = src(y2, x1);
-            out = out + src_reg * ((x2 - x) * (y - y1));
+        return saturate_cast<elem_type>(out);
+    }
 
-            src_reg = src(y2, x2);
-            out = out + src_reg * ((x - x1) * (y - y1));
+    const Ptr2D src;
+};
 
-            return saturate_cast<elem_type>(out);
-        }
+template <typename Ptr2D> struct CubicFilter
+{
+    typedef typename Ptr2D::elem_type elem_type;
+    typedef float index_type;
+    typedef typename TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;
 
-        const Ptr2D src;
-    };
+    explicit __host__ __device__ __forceinline__ CubicFilter(const Ptr2D& src_) : src(src_) {}
     
-    template <typename Ptr2D> struct CubicFilter
+    static __device__ __forceinline__ work_type cubicInterpolate(const work_type& p0, const work_type& p1, const work_type& p2, const work_type& p3, float x) 
     {
-        typedef typename Ptr2D::elem_type elem_type;
-        typedef float index_type;
-        typedef typename TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;
+        return p1 + 0.5f * x * (p2 - p0 + x * (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3 + x * (3.0f * (p1 - p2) + p3 - p0)));
+    }
 
-        explicit __host__ __device__ __forceinline__ CubicFilter(const Ptr2D& src_) : src(src_) {}
+    __device__ elem_type operator ()(float y, float x) const
+    {
+        const int xi = __float2int_rn(x);
+        const int yi = __float2int_rn(y);
+        
+        work_type arr[4];
         
-        static __device__ __forceinline__ work_type cubicInterpolate(const work_type& p0, const work_type& p1, const work_type& p2, const work_type& p3, float x) 
-        {
-	        return p1 + 0.5f * x * (p2 - p0 + x * (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3 + x * (3.0f * (p1 - p2) + p3 - p0)));
-        }
-
-        __device__ elem_type operator ()(float y, float x) const
-        {
-            const int xi = __float2int_rn(x);
-            const int yi = __float2int_rn(y);
-            
-	        work_type arr[4];
-	        
-	        arr[0] = cubicInterpolate(saturate_cast<work_type>(src(yi - 1, xi - 1)), saturate_cast<work_type>(src(yi - 1, xi)), saturate_cast<work_type>(src(yi - 1, xi + 1)), saturate_cast<work_type>(src(yi - 1, xi + 2)), x - xi);
-	        arr[1] = cubicInterpolate(saturate_cast<work_type>(src(yi    , xi - 1)), saturate_cast<work_type>(src(yi    , xi)), saturate_cast<work_type>(src(yi    , xi + 1)), saturate_cast<work_type>(src(yi    , xi + 2)), x - xi);
-	        arr[2] = cubicInterpolate(saturate_cast<work_type>(src(yi + 1, xi - 1)), saturate_cast<work_type>(src(yi + 1, xi)), saturate_cast<work_type>(src(yi + 1, xi + 1)), saturate_cast<work_type>(src(yi + 1, xi + 2)), x - xi);
-	        arr[3] = cubicInterpolate(saturate_cast<work_type>(src(yi + 2, xi - 1)), saturate_cast<work_type>(src(yi + 2, xi)), saturate_cast<work_type>(src(yi + 2, xi + 1)), saturate_cast<work_type>(src(yi + 2, xi + 2)), x - xi);
-	        
-	        return saturate_cast<elem_type>(cubicInterpolate(arr[0], arr[1], arr[2], arr[3], y - yi));
-        }
-
-        const Ptr2D src;
-    };
-}}}
+        arr[0] = cubicInterpolate(saturate_cast<work_type>(src(yi - 1, xi - 1)), saturate_cast<work_type>(src(yi - 1, xi)), saturate_cast<work_type>(src(yi - 1, xi + 1)), saturate_cast<work_type>(src(yi - 1, xi + 2)), x - xi);
+        arr[1] = cubicInterpolate(saturate_cast<work_type>(src(yi    , xi - 1)), saturate_cast<work_type>(src(yi    , xi)), saturate_cast<work_type>(src(yi    , xi + 1)), saturate_cast<work_type>(src(yi    , xi + 2)), x - xi);
+        arr[2] = cubicInterpolate(saturate_cast<work_type>(src(yi + 1, xi - 1)), saturate_cast<work_type>(src(yi + 1, xi)), saturate_cast<work_type>(src(yi + 1, xi + 1)), saturate_cast<work_type>(src(yi + 1, xi + 2)), x - xi);
+        arr[3] = cubicInterpolate(saturate_cast<work_type>(src(yi + 2, xi - 1)), saturate_cast<work_type>(src(yi + 2, xi)), saturate_cast<work_type>(src(yi + 2, xi + 1)), saturate_cast<work_type>(src(yi + 2, xi + 2)), x - xi);
+        
+        return saturate_cast<elem_type>(cubicInterpolate(arr[0], arr[1], arr[2], arr[3], y - yi));
+    }
+
+    const Ptr2D src;
+};
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_FILTERS_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/funcattrib.hpp b/modules/gpu/src/opencv2/gpu/device/funcattrib.hpp
index a3fe1c2d78a15cb64def59d70bc96aa8a6c0c3c0..49eda6f05b36f765282b1157d7615ff1053ca884 100644
--- a/modules/gpu/src/opencv2/gpu/device/funcattrib.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/funcattrib.hpp
@@ -44,35 +44,31 @@
 #ifndef __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_
 #define __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_
 
-#include<cstdio>
+#include <cstdio>
+#include "internal_shared.hpp"
 
-namespace cv
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template<class Func> 
+void printFuncAttrib(Func& func)
 {
-    namespace gpu
-    {
-        namespace device
-        {
-            template<class Func> 
-            void printFuncAttrib(Func& func)
-            {
 
-                cudaFuncAttributes attrs;
-                cudaFuncGetAttributes(&attrs, func);  
+    cudaFuncAttributes attrs;
+    cudaFuncGetAttributes(&attrs, func);  
 
-                printf("=== Function stats ===\n");
-                printf("Name: \n");
-                printf("sharedSizeBytes    = %d\n", attrs.sharedSizeBytes);
-                printf("constSizeBytes     = %d\n", attrs.constSizeBytes);
-                printf("localSizeBytes     = %d\n", attrs.localSizeBytes);
-                printf("maxThreadsPerBlock = %d\n", attrs.maxThreadsPerBlock);
-                printf("numRegs            = %d\n", attrs.numRegs);
-                printf("ptxVersion         = %d\n", attrs.ptxVersion);
-                printf("binaryVersion      = %d\n", attrs.binaryVersion);
-                printf("\n");
-                fflush(stdout); 
-            }
-        }
-    }
+    printf("=== Function stats ===\n");
+    printf("Name: \n");
+    printf("sharedSizeBytes    = %d\n", attrs.sharedSizeBytes);
+    printf("constSizeBytes     = %d\n", attrs.constSizeBytes);
+    printf("localSizeBytes     = %d\n", attrs.localSizeBytes);
+    printf("maxThreadsPerBlock = %d\n", attrs.maxThreadsPerBlock);
+    printf("numRegs            = %d\n", attrs.numRegs);
+    printf("ptxVersion         = %d\n", attrs.ptxVersion);
+    printf("binaryVersion      = %d\n", attrs.binaryVersion);
+    printf("\n");
+    fflush(stdout); 
 }
 
+END_OPENCV_DEVICE_NAMESPACE
+
 #endif  /* __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_ */
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/functional.hpp b/modules/gpu/src/opencv2/gpu/device/functional.hpp
index 58af91d9dca462b695d65733f96cd63d36f441c8..5f29c0de6f0a46541134126c6686d460969e0428 100644
--- a/modules/gpu/src/opencv2/gpu/device/functional.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/functional.hpp
@@ -49,182 +49,182 @@
 #include "vec_traits.hpp"
 #include "type_traits.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    // Function Objects
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+// Function Objects
 
-    using thrust::unary_function;
-    using thrust::binary_function;
+using thrust::unary_function;
+using thrust::binary_function;
 
-    // Arithmetic Operations
+// Arithmetic Operations
 
-    template <typename T> struct plus : binary_function<T, T, T>
+template <typename T> struct plus : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a + b;
-        }
-    };
-    template <typename T> struct minus : binary_function<T, T, T>
+        return a + b;
+    }
+};
+template <typename T> struct minus : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a - b;
-        }
-    };
-    template <typename T> struct multiplies : binary_function<T, T, T>
+        return a - b;
+    }
+};
+template <typename T> struct multiplies : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a * b;
-        }
-    };
-    template <typename T> struct divides : binary_function<T, T, T>
+        return a * b;
+    }
+};
+template <typename T> struct divides : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a / b;
-        }
-    };
-    template <typename T> struct modulus : binary_function<T, T, T>
+        return a / b;
+    }
+};
+template <typename T> struct modulus : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a % b;
-        }
-    };
-    template <typename T> struct negate : unary_function<T, T>
+        return a % b;
+    }
+};
+template <typename T> struct negate : unary_function<T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a) const
-        {
-            return -a;
-        }
-    };
+        return -a;
+    }
+};
 
-    // Comparison Operations
-    
-    template <typename T> struct equal_to : binary_function<T, T, bool>
+// Comparison Operations
+
+template <typename T> struct equal_to : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a == b;
-        }
-    };
-    template <typename T> struct not_equal_to : binary_function<T, T, bool>
+        return a == b;
+    }
+};
+template <typename T> struct not_equal_to : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a != b;
-        }
-    };
-    template <typename T> struct greater : binary_function<T, T, bool>
+        return a != b;
+    }
+};
+template <typename T> struct greater : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a > b;
-        }
-    };
-    template <typename T> struct less : binary_function<T, T, bool>
+        return a > b;
+    }
+};
+template <typename T> struct less : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a < b;
-        }
-    };
-    template <typename T> struct greater_equal : binary_function<T, T, bool>
+        return a < b;
+    }
+};
+template <typename T> struct greater_equal : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a >= b;
-        }
-    };
-    template <typename T> struct less_equal : binary_function<T, T, bool>
+        return a >= b;
+    }
+};
+template <typename T> struct less_equal : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a <= b;
-        }
-    };
+        return a <= b;
+    }
+};
 
-    // Logical Operations
-    
-    template <typename T> struct logical_and : binary_function<T, T, bool>
+// Logical Operations
+
+template <typename T> struct logical_and : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a && b;
-        }
-    };
-    template <typename T> struct logical_or : binary_function<T, T, bool>
+        return a && b;
+    }
+};
+template <typename T> struct logical_or : binary_function<T, T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a || b;
-        }
-    };
-    template <typename T> struct logical_not : unary_function<T, bool>
+        return a || b;
+    }
+};
+template <typename T> struct logical_not : unary_function<T, bool>
+{
+    __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a) const
     {
-        __device__ __forceinline__ bool operator ()(typename TypeTraits<T>::ParameterType a) const
-        {
-            return !a;
-        }
-    };
+        return !a;
+    }
+};
 
-    // Bitwise Operations
+// Bitwise Operations
 
-    template <typename T> struct bit_and : binary_function<T, T, T>
+template <typename T> struct bit_and : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a & b;
-        }
-    };
-    template <typename T> struct bit_or : binary_function<T, T, T>
+        return a & b;
+    }
+};
+template <typename T> struct bit_or : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a | b;
-        }
-    };
-    template <typename T> struct bit_xor : binary_function<T, T, T>
+        return a | b;
+    }
+};
+template <typename T> struct bit_xor : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType a, typename TypeTraits<T>::ParameterType b) const
-        {
-            return a ^ b;
-        }
-    };
-    template <typename T> struct bit_not : unary_function<T, T>
+        return a ^ b;
+    }
+};
+template <typename T> struct bit_not : unary_function<T, T>
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType v) const 
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType v) const 
-        {
-            return ~v;
-        }
-    };
+        return ~v;
+    }
+};
 
-    // Generalized Identity Operations
+// Generalized Identity Operations
 
-    template <typename T> struct identity : unary_function<T, T>
+template <typename T> struct identity : unary_function<T, T>
+{
+    __device__ __forceinline__ typename TypeTraits<T>::ParameterType operator()(typename TypeTraits<T>::ParameterType x) const 
     {
-        __device__ __forceinline__ typename TypeTraits<T>::ParameterType operator()(typename TypeTraits<T>::ParameterType x) const 
-        {
-            return x;
-        }
-    };
+        return x;
+    }
+};
 
-    template <typename T1, typename T2> struct project1st : binary_function<T1, T2, T1>
+template <typename T1, typename T2> struct project1st : binary_function<T1, T2, T1>
+{
+    __device__ __forceinline__ typename TypeTraits<T1>::ParameterType operator()(typename TypeTraits<T1>::ParameterType lhs, typename TypeTraits<T2>::ParameterType rhs) const 
     {
-        __device__ __forceinline__ typename TypeTraits<T1>::ParameterType operator()(typename TypeTraits<T1>::ParameterType lhs, typename TypeTraits<T2>::ParameterType rhs) const 
-        {
-            return lhs;
-        }
-    };
-    template <typename T1, typename T2> struct project2nd : binary_function<T1, T2, T2>
+        return lhs;
+    }
+};
+template <typename T1, typename T2> struct project2nd : binary_function<T1, T2, T2>
+{
+    __device__ __forceinline__ typename TypeTraits<T2>::ParameterType operator()(typename TypeTraits<T1>::ParameterType lhs, typename TypeTraits<T2>::ParameterType rhs) const 
     {
-        __device__ __forceinline__ typename TypeTraits<T2>::ParameterType operator()(typename TypeTraits<T1>::ParameterType lhs, typename TypeTraits<T2>::ParameterType rhs) const 
-        {
-            return rhs;
-        }
-    };
+        return rhs;
+    }
+};
 
     // Min/Max Operations
 
@@ -234,39 +234,39 @@ namespace cv { namespace gpu { namespace device
         __device__ __forceinline__ type operator()(type lhs, type rhs) const {return op(lhs, rhs);} \
     };
 
-    template <typename T> struct maximum : binary_function<T, T, T>
+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 
     {
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType lhs, typename TypeTraits<T>::ParameterType rhs) const 
-        {
-            return lhs < rhs ? rhs : lhs;
-        }
-    };
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uchar, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, schar, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, char, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, ushort, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, short, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, int, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uint, max)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, float, fmax)
-    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, double, fmax)
-
-    template <typename T> struct minimum : binary_function<T, T, T>
-    {
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType lhs, typename TypeTraits<T>::ParameterType rhs) const 
-        {
-            return lhs < rhs ? lhs : rhs;
-        }
-    };
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uchar, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, schar, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, char, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, ushort, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, short, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, int, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uint, min)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, float, fmin)
-    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, double, fmin)
+        return lhs < rhs ? rhs : lhs;
+    }
+};
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uchar, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, schar, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, char, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, ushort, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, short, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, int, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uint, ::max)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, float, ::fmax)
+OPENCV_GPU_IMPLEMENT_MINMAX(maximum, double, ::fmax)
+
+template <typename T> struct minimum : binary_function<T, T, T>
+{
+    __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType lhs, typename TypeTraits<T>::ParameterType rhs) const 
+    {
+        return lhs < rhs ? lhs : rhs;
+    }
+};
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uchar, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, schar, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, char, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, ushort, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, short, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, int, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uint, ::min)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, float, ::fmin)
+OPENCV_GPU_IMPLEMENT_MINMAX(minimum, double, ::fmin)
 
 #undef OPENCV_GPU_IMPLEMENT_MINMAX
 
@@ -277,14 +277,14 @@ namespace cv { namespace gpu { namespace device
     { \
         __device__ __forceinline__ float operator ()(typename TypeTraits<T>::ParameterType v) const \
         { \
-            return func ## f(v); \
+            return :: ## func ## f(v); \
         } \
     }; \
     template <> struct func ## _func<double> : unary_function<double, double> \
     { \
         __device__ __forceinline__ double operator ()(double v) const \
         { \
-            return func(v); \
+            return :: ## func(v); \
         } \
     };
 #define OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(func) \
@@ -292,266 +292,270 @@ namespace cv { namespace gpu { namespace device
     { \
         __device__ __forceinline__ float operator ()(typename TypeTraits<T>::ParameterType v1, typename TypeTraits<T>::ParameterType v2) const \
         { \
-            return func ## f(v1, v2); \
+            return :: ## func ## f(v1, v2); \
         } \
     }; \
     template <> struct func ## _func<double> : binary_function<double, double, double> \
     { \
         __device__ __forceinline__ double operator ()(double v1, double v2) const \
         { \
-            return func(v1, v2); \
+            return :: ## func(v1, v2); \
         } \
     };
 
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(fabs)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sqrt)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp2)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp10)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log2)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log10)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sin)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cos)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tan)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asin)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acos)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atan)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sinh)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cosh)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tanh)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asinh)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acosh)
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atanh)
-
-    OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(hypot)
-    OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(atan2)
-    OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(pow)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(fabs)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sqrt)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp2)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp10)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log2)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log10)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sin)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cos)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tan)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asin)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acos)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atan)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sinh)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cosh)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tanh)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asinh)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acosh)
+OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atanh)
+
+OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(hypot)
+OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(atan2)
+OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(pow)
 
 #undef OPENCV_GPU_IMPLEMENT_UN_FUNCTOR
 #undef OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR
 
-    template<typename T> struct hypot_sqr_func : binary_function<T, T, float> 
+template<typename T> struct hypot_sqr_func : binary_function<T, T, float> 
+{
+    __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType src1, typename TypeTraits<T>::ParameterType src2) const
     {
-        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType src1, typename TypeTraits<T>::ParameterType src2) const
-        {
-            return src1 * src1 + src2 * src2;
-        }
-    };
+        return src1 * src1 + src2 * src2;
+    }
+};
 
-    // Saturate Cast Functor
+// Saturate Cast Functor
 
-    template <typename T, typename D> struct saturate_cast_func : unary_function<T, D>
+template <typename T, typename D> struct saturate_cast_func : unary_function<T, D>
+{
+    __device__ __forceinline__ D operator ()(typename TypeTraits<T>::ParameterType v) const
     {
-        __device__ __forceinline__ D operator ()(typename TypeTraits<T>::ParameterType v) const
-        {
-            return saturate_cast<D>(v);
-        }
-    };
+        return saturate_cast<D>(v);
+    }
+};
+
+// Threshold Functors
 
-    // Threshold Functors
+template <typename T> struct thresh_binary_func : unary_function<T, T>
+{
+    __host__ __device__ __forceinline__ thresh_binary_func(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
 
-    template <typename T> struct thresh_binary_func : unary_function<T, T>
+    __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
     {
-        __host__ __device__ __forceinline__ thresh_binary_func(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
+        return (src > thresh) * maxVal;
+    }
 
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
-        {
-            return (src > thresh) * maxVal;
-        }
+    const T thresh;
+    const T maxVal;
+};
+template <typename T> struct thresh_binary_inv_func : unary_function<T, T>
+{
+    __host__ __device__ __forceinline__ thresh_binary_inv_func(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
 
-        const T thresh;
-        const T maxVal;
-    };
-    template <typename T> struct thresh_binary_inv_func : unary_function<T, T>
+    __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
     {
-        __host__ __device__ __forceinline__ thresh_binary_inv_func(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
+        return (src <= thresh) * maxVal;
+    }
 
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
-        {
-            return (src <= thresh) * maxVal;
-        }
+    const T thresh;
+    const T maxVal;
+};
+template <typename T> struct thresh_trunc_func : unary_function<T, T>
+{
+    explicit __host__ __device__ __forceinline__ thresh_trunc_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
 
-        const T thresh;
-        const T maxVal;
-    };
-    template <typename T> struct thresh_trunc_func : unary_function<T, T>
+    __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
     {
-        explicit __host__ __device__ __forceinline__ thresh_trunc_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
+        return minimum<T>()(src, thresh);
+    }
 
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
-        {
-            return minimum<T>()(src, thresh);
-        }
+    const T thresh;
+};
+template <typename T> struct thresh_to_zero_func : unary_function<T, T>
+{
+    explicit __host__ __device__ __forceinline__ thresh_to_zero_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
 
-        const T thresh;
-    };
-    template <typename T> struct thresh_to_zero_func : unary_function<T, T>
+    __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
     {
-        explicit __host__ __device__ __forceinline__ thresh_to_zero_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
+        return (src > thresh) * src;
+    }
 
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
-        {
-            return (src > thresh) * src;
-        }
+    const T thresh;
+};
+template <typename T> struct thresh_to_zero_inv_func : unary_function<T, T>
+{
+    explicit __host__ __device__ __forceinline__ thresh_to_zero_inv_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
 
-        const T thresh;
-    };
-    template <typename T> struct thresh_to_zero_inv_func : unary_function<T, T>
+    __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
     {
-        explicit __host__ __device__ __forceinline__ thresh_to_zero_inv_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
+        return (src <= thresh) * src;
+    }
 
-        __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType src) const
-        {
-            return (src <= thresh) * src;
-        }
+    const T thresh;
+};
 
-        const T thresh;
-    };    
+// Function Object Adaptors
 
-    // Function Object Adaptors
+template <typename Predicate> struct unary_negate : unary_function<typename Predicate::argument_type, bool>
+{
+  explicit __host__ __device__ __forceinline__ unary_negate(const Predicate& p) : pred(p) {}
 
-    template <typename Predicate> struct unary_negate : unary_function<typename Predicate::argument_type, bool>
-    {
-      explicit __host__ __device__ __forceinline__ unary_negate(const Predicate& p) : pred(p) {}
+  __device__ __forceinline__ bool operator()(typename TypeTraits<typename Predicate::argument_type>::ParameterType x) const
+  { 
+      return !pred(x); 
+  }
 
-      __device__ __forceinline__ bool operator()(typename TypeTraits<typename Predicate::argument_type>::ParameterType x) const
-      { 
-          return !pred(x); 
-      }
+  const Predicate pred;
+};
+template <typename Predicate> __host__ __device__ __forceinline__ unary_negate<Predicate> not1(const Predicate& pred)
+{
+    return unary_negate<Predicate>(pred);
+}
 
-      const Predicate pred;
-    };
-    template <typename Predicate> __host__ __device__ __forceinline__ unary_negate<Predicate> not1(const Predicate& pred)
-    {
-        return unary_negate<Predicate>(pred);
+template <typename Predicate> struct binary_negate : binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>
+{
+    explicit __host__ __device__ __forceinline__ binary_negate(const Predicate& p) : pred(p) {}
+
+    __device__ __forceinline__ bool operator()(typename TypeTraits<typename Predicate::first_argument_type>::ParameterType x, typename TypeTraits<typename Predicate::second_argument_type>::ParameterType y) const
+    { 
+        return !pred(x,y); 
     }
 
-    template <typename Predicate> struct binary_negate : binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>
-    {
-        explicit __host__ __device__ __forceinline__ binary_negate(const Predicate& p) : pred(p) {}
+    const Predicate pred;
+};
+template <typename BinaryPredicate> __host__ __device__ __forceinline__ binary_negate<BinaryPredicate> not2(const BinaryPredicate& pred)
+{
+    return binary_negate<BinaryPredicate>(pred);
+}
 
-        __device__ __forceinline__ bool operator()(typename TypeTraits<typename Predicate::first_argument_type>::ParameterType x, typename TypeTraits<typename Predicate::second_argument_type>::ParameterType y) const
-        { 
-            return !pred(x,y); 
-        }
+template <typename Op> struct binder1st : unary_function<typename Op::second_argument_type, typename Op::result_type> 
+{
+    __host__ __device__ __forceinline__ binder1st(const Op& op_, const typename Op::first_argument_type& arg1_) : op(op_), arg1(arg1_) {}
 
-        const Predicate pred;
-    };
-    template <typename BinaryPredicate> __host__ __device__ __forceinline__ binary_negate<BinaryPredicate> not2(const BinaryPredicate& pred)
+    __device__ __forceinline__ typename Op::result_type operator ()(typename TypeTraits<typename Op::second_argument_type>::ParameterType a) const
     {
-        return binary_negate<BinaryPredicate>(pred);
+        return op(arg1, a);
     }
 
-    template <typename Op> struct binder1st : unary_function<typename Op::second_argument_type, typename Op::result_type> 
-    {
-        __host__ __device__ __forceinline__ binder1st(const Op& op_, const typename Op::first_argument_type& arg1_) : op(op_), arg1(arg1_) {}
+    const Op op;
+    const typename Op::first_argument_type arg1;
+};
+template <typename Op, typename T> __host__ __device__ __forceinline__ binder1st<Op> bind1st(const Op& op, const T& x)
+{
+    return binder1st<Op>(op, typename Op::first_argument_type(x));
+}
 
-        __device__ __forceinline__ typename Op::result_type operator ()(typename TypeTraits<typename Op::second_argument_type>::ParameterType a) const
-        {
-            return op(arg1, a);
-        }
+template <typename Op> struct binder2nd : unary_function<typename Op::first_argument_type, typename Op::result_type> 
+{
+    __host__ __device__ __forceinline__ binder2nd(const Op& op_, const typename Op::second_argument_type& arg2_) : op(op_), arg2(arg2_) {}
 
-        const Op op;
-        const typename Op::first_argument_type arg1;
-    };
-    template <typename Op, typename T> __host__ __device__ __forceinline__ binder1st<Op> bind1st(const Op& op, const T& x)
+    __forceinline__ __device__ typename Op::result_type operator ()(typename TypeTraits<typename Op::first_argument_type>::ParameterType a) const
     {
-        return binder1st<Op>(op, typename Op::first_argument_type(x));
+        return op(a, arg2);
     }
 
-    template <typename Op> struct binder2nd : unary_function<typename Op::first_argument_type, typename Op::result_type> 
-    {
-        __host__ __device__ __forceinline__ binder2nd(const Op& op_, const typename Op::second_argument_type& arg2_) : op(op_), arg2(arg2_) {}
+    const Op op;
+    const typename Op::second_argument_type arg2;
+};
+template <typename Op, typename T> __host__ __device__ __forceinline__ binder2nd<Op> bind2nd(const Op& op, const T& x)
+{
+    return binder2nd<Op>(op, typename Op::second_argument_type(x));
+}
 
-        __forceinline__ __device__ typename Op::result_type operator ()(typename TypeTraits<typename Op::first_argument_type>::ParameterType a) const
-        {
-            return op(a, arg2);
-        }
+// Functor Traits
 
-        const Op op;
-        const typename Op::second_argument_type arg2;
-    };
-    template <typename Op, typename T> __host__ __device__ __forceinline__ binder2nd<Op> bind2nd(const Op& op, const T& x)
-    {
-        return binder2nd<Op>(op, typename Op::second_argument_type(x));
-    }
+template <typename F> struct IsUnaryFunction
+{
+    typedef char Yes;
+    struct No {Yes a[2];};
 
-    // Functor Traits
+    template <typename T, typename D> static Yes check(unary_function<T, D>);
+    static No check(...);
 
-    template <typename F> struct IsUnaryFunction
-    {
-        typedef char Yes;
-        struct No {Yes a[2];};
+    static F makeF();
 
-        template <typename T, typename D> static Yes check(unary_function<T, D>);
-        static No check(...);
+    enum { value = (sizeof(check(makeF())) == sizeof(Yes)) };
+};
 
-        static F makeF();
+template <typename F> struct IsBinaryFunction
+{
+    typedef char Yes;
+    struct No {Yes a[2];};
 
-        enum { value = (sizeof(check(makeF())) == sizeof(Yes)) };
-    };
+    template <typename T1, typename T2, typename D> static Yes check(binary_function<T1, T2, D>);
+    static No check(...);
 
-    template <typename F> struct IsBinaryFunction
-    {
-        typedef char Yes;
-        struct No {Yes a[2];};
+    static F makeF();
 
-        template <typename T1, typename T2, typename D> static Yes check(binary_function<T1, T2, D>);
-        static No check(...);
+    enum { value = (sizeof(check(makeF())) == sizeof(Yes)) };
+};
 
-        static F makeF();
+namespace detail
+{
+    template <size_t src_elem_size, size_t dst_elem_size> struct UnOpShift { enum { shift = 1 }; };
+    template <size_t src_elem_size> struct UnOpShift<src_elem_size, 1> { enum { shift = 4 }; };
+    template <size_t src_elem_size> struct UnOpShift<src_elem_size, 2> { enum { shift = 2 }; };
 
-        enum { value = (sizeof(check(makeF())) == sizeof(Yes)) };
+    template <typename T, typename D> struct DefaultUnaryShift
+    {
+        enum { shift = detail::UnOpShift<sizeof(T), sizeof(D)>::shift };
     };
+    
+    template <size_t src_elem_size1, size_t src_elem_size2, size_t dst_elem_size> struct BinOpShift { enum { shift = 1 }; };
+    template <size_t src_elem_size1, size_t src_elem_size2> struct BinOpShift<src_elem_size1, src_elem_size2, 1> { enum { shift = 4 }; };
+    template <size_t src_elem_size1, size_t src_elem_size2> struct BinOpShift<src_elem_size1, src_elem_size2, 2> { enum { shift = 2 }; };
 
-    namespace detail
+    template <typename T1, typename T2, typename D> struct DefaultBinaryShift
     {
-        template <size_t src_elem_size, size_t dst_elem_size> struct UnOpShift { enum { shift = 1 }; };
-        template <size_t src_elem_size> struct UnOpShift<src_elem_size, 1> { enum { shift = 4 }; };
-        template <size_t src_elem_size> struct UnOpShift<src_elem_size, 2> { enum { shift = 2 }; };
+        enum { shift = detail::BinOpShift<sizeof(T1), sizeof(T2), sizeof(D)>::shift };
+    };
 
-        template <typename T, typename D> struct DefaultUnaryShift
-        {
-            enum { shift = detail::UnOpShift<sizeof(T), sizeof(D)>::shift };
-        };
-        
-        template <size_t src_elem_size1, size_t src_elem_size2, size_t dst_elem_size> struct BinOpShift { enum { shift = 1 }; };
-        template <size_t src_elem_size1, size_t src_elem_size2> struct BinOpShift<src_elem_size1, src_elem_size2, 1> { enum { shift = 4 }; };
-        template <size_t src_elem_size1, size_t src_elem_size2> struct BinOpShift<src_elem_size1, src_elem_size2, 2> { enum { shift = 2 }; };
+    template <typename Func, bool unary = IsUnaryFunction<Func>::value> struct ShiftDispatcher;
+    template <typename Func> struct ShiftDispatcher<Func, true>
+    {
+        enum { shift = DefaultUnaryShift<typename Func::argument_type, typename Func::result_type>::shift };
+    };
+    template <typename Func> struct ShiftDispatcher<Func, false>
+    {
+        enum { shift = DefaultBinaryShift<typename Func::first_argument_type, typename Func::second_argument_type, typename Func::result_type>::shift };
+    };
+}
 
-        template <typename T1, typename T2, typename D> struct DefaultBinaryShift
-        {
-            enum { shift = detail::BinOpShift<sizeof(T1), sizeof(T2), sizeof(D)>::shift };
-        };
+template <typename Func> struct DefaultTransformShift
+{
+    enum { shift = detail::ShiftDispatcher<Func>::shift };
+};
 
-        template <typename Func, bool unary = IsUnaryFunction<Func>::value> struct ShiftDispatcher;
-        template <typename Func> struct ShiftDispatcher<Func, true>
-        {
-            enum { shift = DefaultUnaryShift<typename Func::argument_type, typename Func::result_type>::shift };
-        };
-        template <typename Func> struct ShiftDispatcher<Func, false>
-        {
-            enum { shift = DefaultBinaryShift<typename Func::first_argument_type, typename Func::second_argument_type, typename Func::result_type>::shift };
-        };
-    }
+template <typename Func> struct DefaultTransformFunctorTraits
+{
+    enum { simple_block_dim_x = 16 };
+    enum { simple_block_dim_y = 16 };
 
-    template <typename Func> struct DefaultTransformShift
-    {
-        enum { shift = detail::ShiftDispatcher<Func>::shift };
-    };
+    enum { smart_block_dim_x = 16 };
+    enum { smart_block_dim_y = 16 };
+    enum { smart_shift = DefaultTransformShift<Func>::shift };
+};
 
-    template <typename Func> struct DefaultTransformFunctorTraits
-    {
-        enum { simple_block_dim_x = 16 };
-        enum { simple_block_dim_y = 16 };
+template <typename Func> struct TransformFunctorTraits : DefaultTransformFunctorTraits<Func> {};
 
-        enum { smart_block_dim_x = 16 };
-        enum { smart_block_dim_y = 16 };
-        enum { smart_shift = DefaultTransformShift<Func>::shift };
-    };
+#define DEFINE_TRANSFORM_FUNCTOR_TRAITS(type) \
+    template <> struct TransformFunctorTraits< type > : DefaultTransformFunctorTraits< type >
 
-    template <typename Func> struct TransformFunctorTraits : DefaultTransformFunctorTraits<Func> {};
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_FUNCTIONAL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/limits.hpp b/modules/gpu/src/opencv2/gpu/device/limits.hpp
index b0b73f2e3590399b728739a6677f6e43420db9b3..b2e53e1fc471db3affca20430a45403eef38dc90 100644
--- a/modules/gpu/src/opencv2/gpu/device/limits.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/limits.hpp
@@ -43,190 +43,193 @@
 #ifndef __OPENCV_GPU_LIMITS_GPU_HPP__
 #define __OPENCV_GPU_LIMITS_GPU_HPP__
 
-namespace cv { namespace gpu { namespace device
+#include "internal_shared.hpp"
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template<class T> struct numeric_limits
+{
+    typedef T type;
+    __device__ __forceinline__ static type min()  { return type(); };
+    __device__ __forceinline__ static type max() { return type(); };
+    __device__ __forceinline__ static type epsilon() { return type(); }
+    __device__ __forceinline__ static type round_error() { return type(); }
+    __device__ __forceinline__ static type denorm_min()  { return type(); }
+    __device__ __forceinline__ static type infinity() { return type(); }
+    __device__ __forceinline__ static type quiet_NaN() { return type(); }
+    __device__ __forceinline__ static type signaling_NaN() { return T(); }
+    static const bool is_signed;
+};
+
+template<> struct numeric_limits<bool>
+{
+    typedef bool type;
+    __device__ __forceinline__ static type min() { return false; };
+    __device__ __forceinline__ static type max() { return true;  };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = false;
+};
+
+template<> struct numeric_limits<char>
+{
+    typedef char type;
+    __device__ __forceinline__ static type min() { return CHAR_MIN; };
+    __device__ __forceinline__ static type max() { return CHAR_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = (char)-1 == -1;
+};
+
+ template<> struct numeric_limits<signed char>
+{
+    typedef char type;
+    __device__ __forceinline__ static type min() { return CHAR_MIN; };
+    __device__ __forceinline__ static type max() { return CHAR_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = (signed char)-1 == -1;
+};
+
+template<> struct numeric_limits<unsigned char>
+{
+    typedef unsigned char type;
+    __device__ __forceinline__ static type min() { return 0; };
+    __device__ __forceinline__ static type max() { return UCHAR_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = false;
+};
+
+template<> struct numeric_limits<short>
+{
+    typedef short type;
+    __device__ __forceinline__ static type min() { return SHRT_MIN; };
+    __device__ __forceinline__ static type max() { return SHRT_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = true;
+};
+
+template<> struct numeric_limits<unsigned short>
+{
+    typedef unsigned short type;
+    __device__ __forceinline__ static type min() { return 0; };
+    __device__ __forceinline__ static type max() { return USHRT_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = false;
+};
+
+template<> struct numeric_limits<int>
+{
+    typedef int type;
+    __device__ __forceinline__ static type min() { return INT_MIN; };
+    __device__ __forceinline__ static type max() { return INT_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = true;
+};
+
+
+template<> struct numeric_limits<unsigned int>
+{
+    typedef unsigned int type;
+    __device__ __forceinline__ static type min() { return 0; };
+    __device__ __forceinline__ static type max() { return UINT_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = false;
+};
+
+template<> struct numeric_limits<long>
+{
+    typedef long type;
+    __device__ __forceinline__ static type min() { return LONG_MIN; };
+    __device__ __forceinline__ static type max() { return LONG_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = true;
+};
+
+template<> struct numeric_limits<unsigned long>
+{
+    typedef unsigned long type;
+    __device__ __forceinline__ static type min() { return 0; };
+    __device__ __forceinline__ static type max() { return ULONG_MAX; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = false;
+};
+
+template<> struct numeric_limits<float>
+{
+    typedef float type;
+    __device__ __forceinline__ static type min() { return 1.175494351e-38f/*FLT_MIN*/; };
+    __device__ __forceinline__ static type max() { return 3.402823466e+38f/*FLT_MAX*/; };
+    __device__ __forceinline__ static type epsilon() { return 1.192092896e-07f/*FLT_EPSILON*/; };
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = true;
+};
+
+template<> struct numeric_limits<double>
 {
-    template<class T> struct numeric_limits
-    {
-        typedef T type;
-        __device__ __forceinline__ static type min()  { return type(); };
-        __device__ __forceinline__ static type max() { return type(); };
-        __device__ __forceinline__ static type epsilon() { return type(); }
-        __device__ __forceinline__ static type round_error() { return type(); }
-        __device__ __forceinline__ static type denorm_min()  { return type(); }
-        __device__ __forceinline__ static type infinity() { return type(); }
-        __device__ __forceinline__ static type quiet_NaN() { return type(); }
-        __device__ __forceinline__ static type signaling_NaN() { return T(); }
-        static const bool is_signed;
-    };
-
-    template<> struct numeric_limits<bool>
-    {
-        typedef bool type;
-        __device__ __forceinline__ static type min() { return false; };
-        __device__ __forceinline__ static type max() { return true;  };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = false;
-    };
-
-    template<> struct numeric_limits<char>
-    {
-        typedef char type;
-        __device__ __forceinline__ static type min() { return CHAR_MIN; };
-        __device__ __forceinline__ static type max() { return CHAR_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = (char)-1 == -1;
-    };
-
-     template<> struct numeric_limits<signed char>
-    {
-        typedef char type;
-        __device__ __forceinline__ static type min() { return CHAR_MIN; };
-        __device__ __forceinline__ static type max() { return CHAR_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = (signed char)-1 == -1;
-    };
-
-    template<> struct numeric_limits<unsigned char>
-    {
-        typedef unsigned char type;
-        __device__ __forceinline__ static type min() { return 0; };
-        __device__ __forceinline__ static type max() { return UCHAR_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = false;
-    };
-
-    template<> struct numeric_limits<short>
-    {
-        typedef short type;
-        __device__ __forceinline__ static type min() { return SHRT_MIN; };
-        __device__ __forceinline__ static type max() { return SHRT_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = true;
-    };
-
-    template<> struct numeric_limits<unsigned short>
-    {
-        typedef unsigned short type;
-        __device__ __forceinline__ static type min() { return 0; };
-        __device__ __forceinline__ static type max() { return USHRT_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = false;
-    };
-
-    template<> struct numeric_limits<int>
-    {
-        typedef int type;
-        __device__ __forceinline__ static type min() { return INT_MIN; };
-        __device__ __forceinline__ static type max() { return INT_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = true;
-    };
-
-
-    template<> struct numeric_limits<unsigned int>
-    {
-        typedef unsigned int type;
-        __device__ __forceinline__ static type min() { return 0; };
-        __device__ __forceinline__ static type max() { return UINT_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = false;
-    };
-
-    template<> struct numeric_limits<long>
-    {
-        typedef long type;
-        __device__ __forceinline__ static type min() { return LONG_MIN; };
-        __device__ __forceinline__ static type max() { return LONG_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = true;
-    };
-
-    template<> struct numeric_limits<unsigned long>
-    {
-        typedef unsigned long type;
-        __device__ __forceinline__ static type min() { return 0; };
-        __device__ __forceinline__ static type max() { return ULONG_MAX; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = false;
-    };
-
-    template<> struct numeric_limits<float>
-    {
-        typedef float type;
-        __device__ __forceinline__ static type min() { return 1.175494351e-38f/*FLT_MIN*/; };
-        __device__ __forceinline__ static type max() { return 3.402823466e+38f/*FLT_MAX*/; };
-        __device__ __forceinline__ static type epsilon() { return 1.192092896e-07f/*FLT_EPSILON*/; };
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = true;
-    };
-
-    template<> struct numeric_limits<double>
-    {
-        typedef double type;
-        __device__ __forceinline__ static type min() { return 2.2250738585072014e-308/*DBL_MIN*/; };
-        __device__ __forceinline__ static type max() { return 1.7976931348623158e+308/*DBL_MAX*/; };
-        __device__ __forceinline__ static type epsilon();
-        __device__ __forceinline__ static type round_error();
-        __device__ __forceinline__ static type denorm_min();
-        __device__ __forceinline__ static type infinity();
-        __device__ __forceinline__ static type quiet_NaN();
-        __device__ __forceinline__ static type signaling_NaN();
-        static const bool is_signed = true;
-    };
-}}}
+    typedef double type;
+    __device__ __forceinline__ static type min() { return 2.2250738585072014e-308/*DBL_MIN*/; };
+    __device__ __forceinline__ static type max() { return 1.7976931348623158e+308/*DBL_MAX*/; };
+    __device__ __forceinline__ static type epsilon();
+    __device__ __forceinline__ static type round_error();
+    __device__ __forceinline__ static type denorm_min();
+    __device__ __forceinline__ static type infinity();
+    __device__ __forceinline__ static type quiet_NaN();
+    __device__ __forceinline__ static type signaling_NaN();
+    static const bool is_signed = true;
+};
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_LIMITS_GPU_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp b/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp
index ca6159f3fd0b67f67cce41ce11f7f337a9715877..34cbbbf25ec36ff8789f8acad1af9c0139010c74 100644
--- a/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp
@@ -45,122 +45,173 @@
 
 #include "internal_shared.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(uchar v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(schar v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(ushort v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(short v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(uint v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(int v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(float v) { return _Tp(v); }
-    template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(double v) { return _Tp(v); }
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(uchar v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(schar v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(ushort v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(short v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(uint v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(int v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(float v) { return _Tp(v); }
+template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(double v) { return _Tp(v); }
 
-    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); }
-    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(short v)
-    { return saturate_cast<uchar>((uint)v); }
+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); 
+}
+template<> __device__ __forceinline__ uchar saturate_cast<uchar>(short v)
+{ 
+    return saturate_cast<uchar>((uint)v); 
+}
+
+template<> __device__ __forceinline__ uchar saturate_cast<uchar>(float v)
+{ 
+    int iv = __float2int_rn(v); 
+    return saturate_cast<uchar>(iv); 
+}
+template<> __device__ __forceinline__ uchar saturate_cast<uchar>(double v)
+{
+#if __CUDA_ARCH__ >= 130
+    int iv = __double2int_rn(v); 
+    return saturate_cast<uchar>(iv);
+#else
+    return saturate_cast<uchar>((float)v);
+#endif
+}
 
-    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(float v)
-    { int iv = __float2int_rn(v); return saturate_cast<uchar>(iv); }
-    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);
-    #else
-        return saturate_cast<uchar>((float)v);
-    #endif
-    }
+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);
+}
+template<> __device__ __forceinline__ schar saturate_cast<schar>(short v)
+{ 
+    return saturate_cast<schar>((int)v); 
+}
+template<> __device__ __forceinline__ schar saturate_cast<schar>(uint v)
+{ 
+    return (schar) ::min(v, (uint)SCHAR_MAX); 
+}
 
-    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);
-    }
-    template<> __device__ __forceinline__ schar saturate_cast<schar>(short v)
-    { return saturate_cast<schar>((int)v); }
-    template<> __device__ __forceinline__ schar saturate_cast<schar>(uint v)
-    { return (schar)min(v, (uint)SCHAR_MAX); }
+template<> __device__ __forceinline__ schar saturate_cast<schar>(float v)
+{ 
+    int iv = __float2int_rn(v); 
+    return saturate_cast<schar>(iv); 
+}
+template<> __device__ __forceinline__ schar saturate_cast<schar>(double v)
+{             
+#if __CUDA_ARCH__ >= 130
+    int iv = __double2int_rn(v); 
+    return saturate_cast<schar>(iv);
+#else
+    return saturate_cast<schar>((float)v);
+#endif
+}
 
-    template<> __device__ __forceinline__ schar saturate_cast<schar>(float v)
-    { int iv = __float2int_rn(v); return saturate_cast<schar>(iv); }
-    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);
-    #else
-        return saturate_cast<schar>((float)v);
-    #endif
-    }
+template<> __device__ __forceinline__ ushort saturate_cast<ushort>(schar v)
+{ 
+    return (ushort) ::max((int)v, 0); 
+}
+template<> __device__ __forceinline__ ushort saturate_cast<ushort>(short v)
+{ 
+    return (ushort) ::max((int)v, 0); 
+}
+template<> __device__ __forceinline__ ushort saturate_cast<ushort>(int v)
+{ 
+    return (ushort)((uint)v <= (uint)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); 
+}
+template<> __device__ __forceinline__ ushort saturate_cast<ushort>(uint v)
+{ 
+    return (ushort) ::min(v, (uint)USHRT_MAX); 
+}
+template<> __device__ __forceinline__ ushort saturate_cast<ushort>(float v)
+{
+    int iv = __float2int_rn(v); 
+    return saturate_cast<ushort>(iv); 
+}
+template<> __device__ __forceinline__ ushort saturate_cast<ushort>(double v)
+{             
+#if __CUDA_ARCH__ >= 130
+    int iv = __double2int_rn(v); 
+    return saturate_cast<ushort>(iv);
+#else
+    return saturate_cast<ushort>((float)v);
+#endif
+}
 
-    template<> __device__ __forceinline__ ushort saturate_cast<ushort>(schar v)
-    { return (ushort)max((int)v, 0); }
-    template<> __device__ __forceinline__ ushort saturate_cast<ushort>(short v)
-    { return (ushort)max((int)v, 0); }
-    template<> __device__ __forceinline__ ushort saturate_cast<ushort>(int v)
-    { return (ushort)((uint)v <= (uint)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
-    template<> __device__ __forceinline__ ushort saturate_cast<ushort>(uint v)
-    { return (ushort)min(v, (uint)USHRT_MAX); }
-    template<> __device__ __forceinline__ ushort saturate_cast<ushort>(float v)
-    { int iv = __float2int_rn(v); return saturate_cast<ushort>(iv); }
-    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);
-    #else
-        return saturate_cast<ushort>((float)v);
-    #endif
-    }
+template<> __device__ __forceinline__ short saturate_cast<short>(ushort v)
+{ 
+    return (short) ::min((int)v, SHRT_MAX); 
+}
+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);
+}
+template<> __device__ __forceinline__ short saturate_cast<short>(uint v)
+{ 
+    return (short) ::min(v, (uint)SHRT_MAX); 
+}
+template<> __device__ __forceinline__ short saturate_cast<short>(float v)
+{ 
+    int iv = __float2int_rn(v); 
+    return saturate_cast<short>(iv); 
+}
+template<> __device__ __forceinline__ short saturate_cast<short>(double v)
+{            
+#if __CUDA_ARCH__ >= 130
+    int iv = __double2int_rn(v); 
+    return saturate_cast<short>(iv);
+#else
+    return saturate_cast<short>((float)v);
+#endif
+}
 
-    template<> __device__ __forceinline__ short saturate_cast<short>(ushort v)
-    { return (short)min((int)v, SHRT_MAX); }
-    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);
-    }
-    template<> __device__ __forceinline__ short saturate_cast<short>(uint v)
-    { return (short)min(v, (uint)SHRT_MAX); }
-    template<> __device__ __forceinline__ short saturate_cast<short>(float v)
-    { int iv = __float2int_rn(v); return saturate_cast<short>(iv); }
-    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);
-    #else
-        return saturate_cast<short>((float)v);
-    #endif
-    }
+template<> __device__ __forceinline__ int saturate_cast<int>(float v) 
+{ 
+    return __float2int_rn(v); 
+}
+template<> __device__ __forceinline__ int saturate_cast<int>(double v) 
+{
+#if __CUDA_ARCH__ >= 130 
+    return __double2int_rn(v);
+#else
+    return saturate_cast<int>((float)v);
+#endif
+}
 
-    template<> __device__ __forceinline__ int saturate_cast<int>(float v) { return __float2int_rn(v); }
-    template<> __device__ __forceinline__ int saturate_cast<int>(double v) 
-    {
-    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130 
-        return __double2int_rn(v);
-    #else
-        return saturate_cast<int>((float)v);
-    #endif
-    }
+template<> __device__ __forceinline__ uint saturate_cast<uint>(float v)
+{ 
+    return __float2uint_rn(v); 
+}
+template<> __device__ __forceinline__ uint saturate_cast<uint>(double v) 
+{            
+#if __CUDA_ARCH__ >= 130
+    return __double2uint_rn(v);
+#else
+    return saturate_cast<uint>((float)v);
+#endif
+}
 
-    template<> __device__ __forceinline__ uint saturate_cast<uint>(float v){ return __float2uint_rn(v); }
-    template<> __device__ __forceinline__ uint saturate_cast<uint>(double v) 
-    {            
-    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
-        return __double2uint_rn(v);
-    #else
-        return saturate_cast<uint>((float)v);
-    #endif
-    }
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif /* __OPENCV_GPU_SATURATE_CAST_HPP__ */
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/transform.hpp b/modules/gpu/src/opencv2/gpu/device/transform.hpp
index 47872926c44d3a3c9752750798b65250e37e85bf..81f427d435d7de77be889fecd5c8c7da9dd922e7 100644
--- a/modules/gpu/src/opencv2/gpu/device/transform.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/transform.hpp
@@ -43,32 +43,34 @@
 #ifndef __OPENCV_GPU_TRANSFORM_HPP__
 #define __OPENCV_GPU_TRANSFORM_HPP__
 
-#include "detail/transform_detail.hpp"
+#include "internal_shared.hpp"
 #include "utility.hpp"
+#include "detail/transform_detail.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T, typename D, typename UnOp>
+void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, cudaStream_t stream = 0)
+{
+    detail::transform_caller(src, dst, op, WithOutMask(), stream);
+}
+template <typename T, typename D, typename UnOp>
+void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const PtrStepb& mask, const UnOp& op, cudaStream_t stream = 0)
+{
+    detail::transform_caller(src, dst, op, SingleMask(mask), stream);
+}
+
+template <typename T1, typename T2, typename D, typename BinOp>
+void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, cudaStream_t stream = 0)
+{
+    detail::transform_caller(src1, src2, dst, op, WithOutMask(), stream);
+}
+template <typename T1, typename T2, typename D, typename BinOp>
+void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const PtrStepb& mask, const BinOp& op, cudaStream_t stream = 0)
 {
-    template <typename T, typename D, typename UnOp>
-    void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, cudaStream_t stream = 0)
-    {
-        detail::transform_caller(src, dst, op, WithOutMask(), stream);
-    }
-    template <typename T, typename D, typename UnOp>
-    void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const PtrStepb& mask, const UnOp& op, cudaStream_t stream = 0)
-    {
-        detail::transform_caller(src, dst, op, SingleMask(mask), stream);
-    }
+    detail::transform_caller(src1, src2, dst, op, SingleMask(mask), stream);
+}
 
-    template <typename T1, typename T2, typename D, typename BinOp>
-    void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, cudaStream_t stream = 0)
-    {
-        detail::transform_caller(src1, src2, dst, op, WithOutMask(), stream);
-    }
-    template <typename T1, typename T2, typename D, typename BinOp>
-    void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const PtrStepb& mask, const BinOp& op, cudaStream_t stream = 0)
-    {
-        detail::transform_caller(src1, src2, dst, op, SingleMask(mask), stream);
-    }
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_TRANSFORM_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/type_traits.hpp b/modules/gpu/src/opencv2/gpu/device/type_traits.hpp
index 24f02ef0192d0c7fdf97e80c37b4bae44f8f06b9..9553d2296a8c59a666237f4adffb1d6499ddfe52 100644
--- a/modules/gpu/src/opencv2/gpu/device/type_traits.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/type_traits.hpp
@@ -43,38 +43,40 @@
 #ifndef __OPENCV_GPU_TYPE_TRAITS_HPP__
 #define __OPENCV_GPU_TYPE_TRAITS_HPP__
 
+#include "internal_shared.hpp"
 #include "detail/type_traits_detail.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T> struct IsSimpleParameter
+{
+    enum {value = detail::IsIntegral<T>::value || detail::IsFloat<T>::value || detail::PointerTraits<typename detail::ReferenceTraits<T>::type>::value};
+};
+
+template <typename T> struct TypeTraits
 {
-    template <typename T> struct IsSimpleParameter
-    {
-        enum {value = detail::IsIntegral<T>::value || detail::IsFloat<T>::value || detail::PointerTraits<typename detail::ReferenceTraits<T>::type>::value};
-    };
+    typedef typename detail::UnConst<T>::type                                       NonConstType;
+    typedef typename detail::UnVolatile<T>::type                                    NonVolatileType;
+    typedef typename detail::UnVolatile<typename detail::UnConst<T>::type>::type    UnqualifiedType;
+    typedef typename detail::PointerTraits<UnqualifiedType>::type                   PointeeType;
+    typedef typename detail::ReferenceTraits<T>::type                               ReferredType;
 
-    template <typename T> struct TypeTraits
-    {
-        typedef typename detail::UnConst<T>::type                                       NonConstType;
-        typedef typename detail::UnVolatile<T>::type                                    NonVolatileType;
-        typedef typename detail::UnVolatile<typename detail::UnConst<T>::type>::type    UnqualifiedType;
-        typedef typename detail::PointerTraits<UnqualifiedType>::type                   PointeeType;
-        typedef typename detail::ReferenceTraits<T>::type                               ReferredType;
+    enum { isConst          = detail::UnConst<T>::value };
+    enum { isVolatile       = detail::UnVolatile<T>::value };
 
-        enum { isConst          = detail::UnConst<T>::value };
-        enum { isVolatile       = detail::UnVolatile<T>::value };
+    enum { isReference      = detail::ReferenceTraits<UnqualifiedType>::value };
+    enum { isPointer        = detail::PointerTraits<typename detail::ReferenceTraits<UnqualifiedType>::type>::value };        
 
-        enum { isReference      = detail::ReferenceTraits<UnqualifiedType>::value };
-        enum { isPointer        = detail::PointerTraits<typename detail::ReferenceTraits<UnqualifiedType>::type>::value };        
+    enum { isUnsignedInt = detail::IsUnsignedIntegral<UnqualifiedType>::value };
+    enum { isSignedInt   = detail::IsSignedIntergral<UnqualifiedType>::value };
+    enum { isIntegral    = detail::IsIntegral<UnqualifiedType>::value };
+    enum { isFloat       = detail::IsFloat<UnqualifiedType>::value  };
+    enum { isArith       = isIntegral || isFloat };
+    enum { isVec         = detail::IsVec<UnqualifiedType>::value  };
+    
+    typedef typename detail::Select<IsSimpleParameter<UnqualifiedType>::value, T, typename detail::AddParameterType<T>::type>::type ParameterType;
+};
 
-        enum { isUnsignedInt = detail::IsUnsignedIntegral<UnqualifiedType>::value };
-        enum { isSignedInt   = detail::IsSignedIntergral<UnqualifiedType>::value };
-        enum { isIntegral    = detail::IsIntegral<UnqualifiedType>::value };
-        enum { isFloat       = detail::IsFloat<UnqualifiedType>::value  };
-        enum { isArith       = isIntegral || isFloat };
-        enum { isVec         = detail::IsVec<UnqualifiedType>::value  };
-        
-        typedef typename detail::Select<IsSimpleParameter<UnqualifiedType>::value, T, typename detail::AddParameterType<T>::type>::type ParameterType;
-    };
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_TYPE_TRAITS_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/utility.hpp b/modules/gpu/src/opencv2/gpu/device/utility.hpp
index aaa8052bfbff0f64c593ad800d4cc03009b16222..0acdd787c6fc1f2b6efb3640391e5ca73b52b098 100644
--- a/modules/gpu/src/opencv2/gpu/device/utility.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/utility.hpp
@@ -48,152 +48,168 @@
 #include "datamov_utils.hpp"
 #include "detail/utility_detail.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
 #define OPENCV_GPU_LOG_WARP_SIZE	    (5)
 #define OPENCV_GPU_WARP_SIZE	        (1 << OPENCV_GPU_LOG_WARP_SIZE)
 #define OPENCV_GPU_LOG_MEM_BANKS        ((__CUDA_ARCH__ >= 200) ? 5 : 4) // 32 banks on fermi, 16 on tesla
 #define OPENCV_GPU_MEM_BANKS            (1 << OPENCV_GPU_LOG_MEM_BANKS)
 
-namespace cv {  namespace gpu { namespace device
+///////////////////////////////////////////////////////////////////////////////
+// swap
+
+template <typename T> void __device__ __host__ __forceinline__ swap(T& a, T& b) 
 {
-    ///////////////////////////////////////////////////////////////////////////////
-    // swap
+    const T temp = a;
+    a = b;
+    b = temp;
+}
 
-    template <typename T> void __device__ __host__ __forceinline__ swap(T& a, T& b) 
-    {
-        const T temp = a;
-        a = b;
-        b = temp;
+///////////////////////////////////////////////////////////////////////////////
+// Mask Reader
+
+struct SingleMask
+{
+    explicit __host__ __device__ __forceinline__ SingleMask(const PtrStepb& mask_) : mask(mask_) {}
+    
+    __device__ __forceinline__ bool operator()(int y, int x) const
+    {            
+        return mask.ptr(y)[x] != 0;
     }
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Mask Reader
+    const PtrStepb mask;
+};
+
+struct MaskCollection
+{
+    explicit __host__ __device__ __forceinline__ MaskCollection(PtrStepb* maskCollection_) : maskCollection(maskCollection_) {}
 
-    struct SingleMask
+    __device__ __forceinline__ void next()
+    {
+        curMask = *maskCollection++;
+    }
+    __device__ __forceinline__ void setMask(int z)
     {
-        explicit __host__ __device__ __forceinline__ SingleMask(const PtrStepb& mask_) : mask(mask_) {}
-        
-        __device__ __forceinline__ bool operator()(int y, int x) const
-        {            
-            return mask.ptr(y)[x] != 0;
-        }
+        curMask = maskCollection[z];
+    }
+    
+    __device__ __forceinline__ bool operator()(int y, int x) const
+    {
+        uchar val;
+        return curMask.data == 0 || (ForceGlob<uchar>::Load(curMask.ptr(y), x, val), (val != 0));
+    }
 
-        const PtrStepb mask;
-    };
+    const PtrStepb* maskCollection;
+    PtrStepb curMask;
+};
 
-    struct MaskCollection
+struct WithOutMask
+{
+    __device__ __forceinline__ void next() const
     {
-        explicit __host__ __device__ __forceinline__ MaskCollection(PtrStepb* maskCollection_) : maskCollection(maskCollection_) {}
-
-        __device__ __forceinline__ void next()
-        {
-            curMask = *maskCollection++;
-        }
-        __device__ __forceinline__ void setMask(int z)
-        {
-            curMask = maskCollection[z];
-        }
-        
-        __device__ __forceinline__ bool operator()(int y, int x) const
-        {
-            uchar val;
-            return curMask.data == 0 || (ForceGlob<uchar>::Load(curMask.ptr(y), x, val), (val != 0));
-        }
-
-        const PtrStepb* maskCollection;
-        PtrStepb curMask;
-    };
-
-    struct WithOutMask
+    }
+    __device__ __forceinline__ void setMask(int) const
     {
-        __device__ __forceinline__ void next() const
-        {
-        }
-        __device__ __forceinline__ void setMask(int) const
-        {
-        }
-
-        __device__ __forceinline__ bool operator()(int, int) const
-        {
-            return true;
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // Reduction
-
-    template <int n, typename T, typename Op> __device__ __forceinline__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+    }
+
+    __device__ __forceinline__ bool operator()(int, int) const
     {
-        StaticAssert<n >= 8 && n <= 512>::check();
-        detail::ReductionDispatcher<n <= 64>::reduce<n>(data, partial_reduction, tid, op);
+        return true;
     }
 
-    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)
+    __device__ __forceinline__ bool operator()(int, int, int) const
     {
-        StaticAssert<n >= 8 && n <= 512>::check();
-        detail::PredValReductionDispatcher<n <= 64>::reduce<n>(myData, myVal, sdata, sval, tid, pred);
+        return true;
     }
 
-    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)
+    static __device__ __forceinline__ bool check(int, int)
     {
-        StaticAssert<n >= 8 && n <= 512>::check();
-        detail::PredVal2ReductionDispatcher<n <= 64>::reduce<n>(myData, myVal1, myVal2, sdata, sval1, sval2, tid, pred);
+        return true;
     }
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    // Solve linear system
 
-    // solve 2x2 linear system Ax=b
-    template <typename T> __device__ __forceinline__ bool solve2x2(const T A[2][2], const T b[2], T x[2])
+    static __device__ __forceinline__ bool check(int, int, int)
     {
-        T det = A[0][0] * A[1][1] - A[1][0] * A[0][1];
+        return true;
+    }
+};
 
-        if (det != 0)
-        {
-            double invdet = 1.0 / det;
+///////////////////////////////////////////////////////////////////////////////
+// Reduction
 
-            x[0] = saturate_cast<T>(invdet * (b[0] * A[1][1] - b[1] * A[0][1]));
+template <int n, typename T, typename Op> __device__ __forceinline__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+{
+    StaticAssert<n >= 8 && n <= 512>::check();
+    detail::ReductionDispatcher<n <= 64>::reduce<n>(data, partial_reduction, tid, op);
+}
 
-            x[1] = saturate_cast<T>(invdet * (A[0][0] * b[1] - A[1][0] * b[0]));
+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();
+    detail::PredValReductionDispatcher<n <= 64>::reduce<n>(myData, myVal, sdata, sval, tid, pred);
+}
 
-            return true;
-        }
+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();
+    detail::PredVal2ReductionDispatcher<n <= 64>::reduce<n>(myData, myVal1, myVal2, sdata, sval1, sval2, tid, pred);
+}
+    
+///////////////////////////////////////////////////////////////////////////////
+// Solve linear system
 
-        return false;
-    }
+// solve 2x2 linear system Ax=b
+template <typename T> __device__ __forceinline__ bool solve2x2(const T A[2][2], const T b[2], T x[2])
+{
+    T det = A[0][0] * A[1][1] - A[1][0] * A[0][1];
 
-    // solve 3x3 linear system Ax=b
-    template <typename T> __device__ __forceinline__ bool solve3x3(const T A[3][3], const T b[3], T x[3])
+    if (det != 0)
     {
-        T det = A[0][0] * (A[1][1] * A[2][2] - A[1][2] * A[2][1])
-              - A[0][1] * (A[1][0] * A[2][2] - A[1][2] * A[2][0])
-              + A[0][2] * (A[1][0] * A[2][1] - A[1][1] * A[2][0]);
+        double invdet = 1.0 / det;
 
-        if (det != 0)
-        {
-            double invdet = 1.0 / det;
+        x[0] = saturate_cast<T>(invdet * (b[0] * A[1][1] - b[1] * A[0][1]));
 
-            x[0] = saturate_cast<T>(invdet * 
-                (b[0]    * (A[1][1] * A[2][2] - A[1][2] * A[2][1]) -
-                 A[0][1] * (b[1]    * A[2][2] - A[1][2] * b[2]   ) +
-                 A[0][2] * (b[1]    * A[2][1] - A[1][1] * b[2]   )));
+        x[1] = saturate_cast<T>(invdet * (A[0][0] * b[1] - A[1][0] * b[0]));
 
-            x[1] = saturate_cast<T>(invdet * 
-                (A[0][0] * (b[1]    * A[2][2] - A[1][2] * b[2]   ) -
-                 b[0]    * (A[1][0] * A[2][2] - A[1][2] * A[2][0]) +
-                 A[0][2] * (A[1][0] * b[2]    - b[1]    * A[2][0])));
+        return true;
+    }
 
-            x[2] = saturate_cast<T>(invdet * 
-                (A[0][0] * (A[1][1] * b[2]    - b[1]    * A[2][1]) -
-                 A[0][1] * (A[1][0] * b[2]    - b[1]    * A[2][0]) +
-                 b[0]    * (A[1][0] * A[2][1] - A[1][1] * A[2][0])));
+    return false;
+}
 
-            return true;
-        }
+// solve 3x3 linear system Ax=b
+template <typename T> __device__ __forceinline__ bool solve3x3(const T A[3][3], const T b[3], T x[3])
+{
+    T det = A[0][0] * (A[1][1] * A[2][2] - A[1][2] * A[2][1])
+          - A[0][1] * (A[1][0] * A[2][2] - A[1][2] * A[2][0])
+          + A[0][2] * (A[1][0] * A[2][1] - A[1][1] * A[2][0]);
+
+    if (det != 0)
+    {
+        double invdet = 1.0 / det;
+
+        x[0] = saturate_cast<T>(invdet * 
+            (b[0]    * (A[1][1] * A[2][2] - A[1][2] * A[2][1]) -
+             A[0][1] * (b[1]    * A[2][2] - A[1][2] * b[2]   ) +
+             A[0][2] * (b[1]    * A[2][1] - A[1][1] * b[2]   )));
 
-        return false;
+        x[1] = saturate_cast<T>(invdet * 
+            (A[0][0] * (b[1]    * A[2][2] - A[1][2] * b[2]   ) -
+             b[0]    * (A[1][0] * A[2][2] - A[1][2] * A[2][0]) +
+             A[0][2] * (A[1][0] * b[2]    - b[1]    * A[2][0])));
+
+        x[2] = saturate_cast<T>(invdet * 
+            (A[0][0] * (A[1][1] * b[2]    - b[1]    * A[2][1]) -
+             A[0][1] * (A[1][0] * b[2]    - b[1]    * A[2][0]) +
+             b[0]    * (A[1][0] * A[2][1] - A[1][1] * A[2][0])));
+
+        return true;
     }
-}}}
+
+    return false;
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_UTILITY_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/vec_distance.hpp b/modules/gpu/src/opencv2/gpu/device/vec_distance.hpp
index 5831ae556aea66cbfd47090226f39afce90d32a7..3b84fa592e634f47ac41603da3d176d56c263be8 100644
--- a/modules/gpu/src/opencv2/gpu/device/vec_distance.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/vec_distance.hpp
@@ -48,179 +48,179 @@
 #include "functional.hpp"
 #include "detail/vec_distance_detail.hpp"
 
-namespace cv {  namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+template <typename T> struct L1Dist
 {
+    typedef int value_type;
+    typedef int result_type;
+
+    __device__ __forceinline__ L1Dist() : mySum(0) {}
 
-    template <typename T> struct L1Dist
+    __device__ __forceinline__ void reduceIter(int val1, int val2)
     {
-        typedef int value_type;
-        typedef int result_type;
+        mySum = __sad(val1, val2, mySum);
+    }
 
-        __device__ __forceinline__ L1Dist() : mySum(0) {}
+    template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
+    {
+        reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
+    }
 
-        __device__ __forceinline__ void reduceIter(int val1, int val2)
-        {
-            mySum = __sad(val1, val2, mySum);
-        }
+    __device__ __forceinline__ operator int() const
+    {
+        return mySum;
+    }
 
-        template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
-        {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
-        }
+    int mySum;
+};
+template <> struct L1Dist<float>
+{
+    typedef float value_type;
+    typedef float result_type;
 
-        __device__ __forceinline__ operator int() const
-        {
-            return mySum;
-        }
+    __device__ __forceinline__ L1Dist() : mySum(0.0f) {}
 
-        int mySum;
-    };
-    template <> struct L1Dist<float>
+    __device__ __forceinline__ void reduceIter(float val1, float val2)
     {
-        typedef float value_type;
-        typedef float result_type;
+        mySum += ::fabs(val1 - val2);
+    }
 
-        __device__ __forceinline__ L1Dist() : mySum(0.0f) {}
+    template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
+    {
+        reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
+    }
 
-        __device__ __forceinline__ void reduceIter(float val1, float val2)
-        {
-            mySum += ::fabs(val1 - val2);
-        }
+    __device__ __forceinline__ operator float() const
+    {
+        return mySum;
+    }
 
-        template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
-        {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
-        }
+    float mySum;
+};
 
-        __device__ __forceinline__ operator float() const
-        {
-            return mySum;
-        }
+struct L2Dist
+{
+    typedef float value_type;
+    typedef float result_type;
 
-        float mySum;
-    };
+    __device__ __forceinline__ L2Dist() : mySum(0.0f) {}
 
-    struct L2Dist
+    __device__ __forceinline__ void reduceIter(float val1, float val2)
     {
-        typedef float value_type;
-        typedef float result_type;
+        float reg = val1 - val2;
+        mySum += reg * reg;
+    }
 
-        __device__ __forceinline__ L2Dist() : mySum(0.0f) {}
+    template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
+    {
+        reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
+    }
 
-        __device__ __forceinline__ void reduceIter(float val1, float val2)
-        {
-            float reg = val1 - val2;
-            mySum += reg * reg;
-        }
+    __device__ __forceinline__ operator float() const
+    {
+        return sqrtf(mySum);
+    }
 
-        template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
-        {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
-        }
+    float mySum;
+};
 
-        __device__ __forceinline__ operator float() const
-        {
-            return sqrtf(mySum);
-        }
+struct HammingDist
+{
+    typedef int value_type;
+    typedef int result_type;
 
-        float mySum;
-    };
+    __device__ __forceinline__ HammingDist() : mySum(0) {}
 
-    struct HammingDist
+    __device__ __forceinline__ void reduceIter(int val1, int val2)
     {
-        typedef int value_type;
-        typedef int result_type;
-
-        __device__ __forceinline__ HammingDist() : mySum(0) {}
-
-        __device__ __forceinline__ void reduceIter(int val1, int val2)
-        {
-            mySum += __popc(val1 ^ val2);
-        }
+        mySum += __popc(val1 ^ val2);
+    }
 
-        template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
-        {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
-        }
+    template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
+    {
+        reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
+    }
 
-        __device__ __forceinline__ operator int() const
-        {
-            return mySum;
-        }
+    __device__ __forceinline__ operator int() const
+    {
+        return mySum;
+    }
 
-        int mySum;
-    };
+    int mySum;
+};
 
-    // calc distance between two vectors in global memory
-    template <int THREAD_DIM, typename Dist, typename T1, typename T2> 
-    __device__ void calcVecDiffGlobal(const T1* vec1, const T2* vec2, int len, Dist& dist, typename Dist::result_type* smem, int tid)
+// calc distance between two vectors in global memory
+template <int THREAD_DIM, typename Dist, typename T1, typename T2> 
+__device__ void calcVecDiffGlobal(const T1* vec1, const T2* vec2, int len, Dist& dist, typename Dist::result_type* smem, int tid)
+{
+    for (int i = tid; i < len; i += THREAD_DIM)
     {
-        for (int i = tid; i < len; i += THREAD_DIM)
-        {
-            T1 val1;
-            ForceGlob<T1>::Load(vec1, i, val1);
+        T1 val1;
+        ForceGlob<T1>::Load(vec1, i, val1);
 
-            T2 val2;
-            ForceGlob<T2>::Load(vec2, i, val2);
+        T2 val2;
+        ForceGlob<T2>::Load(vec2, i, val2);
 
-            dist.reduceIter(val1, val2);
-        }
-
-        dist.reduceAll<THREAD_DIM>(smem, tid);
+        dist.reduceIter(val1, val2);
     }
 
-    // calc distance between two vectors, first vector is cached in register or shared memory, second vector is in global memory
-    template <int THREAD_DIM, int MAX_LEN, bool LEN_EQ_MAX_LEN, typename Dist, typename T1, typename T2>
-    __device__ __forceinline__ void calcVecDiffCached(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, typename Dist::result_type* smem, int tid)
-    {        
-        detail::VecDiffCachedCalculator<THREAD_DIM, MAX_LEN, LEN_EQ_MAX_LEN>::calc(vecCached, vecGlob, len, dist, tid);
-        
-        dist.reduceAll<THREAD_DIM>(smem, tid);
-    }
+    dist.reduceAll<THREAD_DIM>(smem, tid);
+}
 
-    // calc distance between two vectors in global memory
-    template <int THREAD_DIM, typename T1> struct VecDiffGlobal
+// calc distance between two vectors, first vector is cached in register or shared memory, second vector is in global memory
+template <int THREAD_DIM, int MAX_LEN, bool LEN_EQ_MAX_LEN, typename Dist, typename T1, typename T2>
+__device__ __forceinline__ void calcVecDiffCached(const T1* vecCached, const T2* vecGlob, int len, Dist& dist, typename Dist::result_type* smem, int tid)
+{        
+    detail::VecDiffCachedCalculator<THREAD_DIM, MAX_LEN, LEN_EQ_MAX_LEN>::calc(vecCached, vecGlob, len, dist, tid);
+    
+    dist.reduceAll<THREAD_DIM>(smem, tid);
+}
+
+// calc distance between two vectors in global memory
+template <int THREAD_DIM, typename T1> struct VecDiffGlobal
+{
+    explicit __device__ __forceinline__ VecDiffGlobal(const T1* vec1_, int = 0, void* = 0, int = 0, int = 0)
     {
-        explicit __device__ __forceinline__ VecDiffGlobal(const T1* vec1_, int = 0, void* = 0, int = 0, int = 0)
-        {
-            vec1 = vec1_;
-        }
+        vec1 = vec1_;
+    }
 
-        template <typename T2, typename Dist>
-        __device__ __forceinline__ void calc(const T2* vec2, int len, Dist& dist, typename Dist::result_type* smem, int tid) const
-        {
-            calcVecDiffGlobal<THREAD_DIM>(vec1, vec2, len, dist, smem, tid);
-        }
+    template <typename T2, typename Dist>
+    __device__ __forceinline__ void calc(const T2* vec2, int len, Dist& dist, typename Dist::result_type* smem, int tid) const
+    {
+        calcVecDiffGlobal<THREAD_DIM>(vec1, vec2, len, dist, smem, tid);
+    }
 
-        const T1* vec1;
-    };
+    const T1* vec1;
+};
 
-    // calc distance between two vectors, first vector is cached in register memory, second vector is in global memory
-    template <int THREAD_DIM, int MAX_LEN, bool LEN_EQ_MAX_LEN, typename U> struct VecDiffCachedRegister
+// calc distance between two vectors, first vector is cached in register memory, second vector is in global memory
+template <int THREAD_DIM, int MAX_LEN, bool LEN_EQ_MAX_LEN, typename U> struct VecDiffCachedRegister
+{
+    template <typename T1> __device__ __forceinline__ VecDiffCachedRegister(const T1* vec1, int len, U* smem, int glob_tid, int tid)
     {
-        template <typename T1> __device__ __forceinline__ VecDiffCachedRegister(const T1* vec1, int len, U* smem, int glob_tid, int tid)
-        {
-            if (glob_tid < len)
-                smem[glob_tid] = vec1[glob_tid];
-            __syncthreads();
+        if (glob_tid < len)
+            smem[glob_tid] = vec1[glob_tid];
+        __syncthreads();
+
+        U* vec1ValsPtr = vec1Vals;
 
-            U* vec1ValsPtr = vec1Vals;
+        #pragma unroll
+        for (int i = tid; i < MAX_LEN; i += THREAD_DIM)
+            *vec1ValsPtr++ = smem[i];
 
-            #pragma unroll
-            for (int i = tid; i < MAX_LEN; i += THREAD_DIM)
-                *vec1ValsPtr++ = smem[i];
+        __syncthreads();
+    }
 
-            __syncthreads();
-        }
+    template <typename T2, typename Dist>
+    __device__ __forceinline__ void calc(const T2* vec2, int len, Dist& dist, typename Dist::result_type* smem, int tid) const
+    {
+        calcVecDiffCached<THREAD_DIM, MAX_LEN, LEN_EQ_MAX_LEN>(vec1Vals, vec2, len, dist, smem, tid);
+    }
 
-        template <typename T2, typename Dist>
-        __device__ __forceinline__ void calc(const T2* vec2, int len, Dist& dist, typename Dist::result_type* smem, int tid) const
-        {
-            calcVecDiffCached<THREAD_DIM, MAX_LEN, LEN_EQ_MAX_LEN>(vec1Vals, vec2, len, dist, smem, tid);
-        }
+    U vec1Vals[MAX_LEN / THREAD_DIM];
+};
 
-        U vec1Vals[MAX_LEN / THREAD_DIM];
-    };
-}}}
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_VEC_DISTANCE_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/vec_math.hpp b/modules/gpu/src/opencv2/gpu/device/vec_math.hpp
index 48aa62f3f7b872c690648c82adcda68f24386334..8fda04184f3b86e978426637192ba3a464ebd80e 100644
--- a/modules/gpu/src/opencv2/gpu/device/vec_math.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/vec_math.hpp
@@ -48,85 +48,85 @@
 #include "vec_traits.hpp"
 #include "functional.hpp"
 
-namespace cv {  namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace detail
 {
-    namespace detail
+    template <int cn, typename VecD> struct SatCastHelper;
+    template <typename VecD> struct SatCastHelper<1, VecD>
     {
-        template <int cn, typename VecD> struct SatCastHelper;
-        template <typename VecD> struct SatCastHelper<1, VecD>
-        {
-            template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
-            {
-                typedef typename VecTraits<VecD>::elem_type D;
-                return VecTraits<VecD>::make(saturate_cast<D>(v.x));
-            }
-        };
-        template <typename VecD> struct SatCastHelper<2, VecD>
+        template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
         {
-            template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
-            {
-                typedef typename VecTraits<VecD>::elem_type D;
-                return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y));
-            }
-        };
-        template <typename VecD> struct SatCastHelper<3, VecD>
+            typedef typename VecTraits<VecD>::elem_type D;
+            return VecTraits<VecD>::make(saturate_cast<D>(v.x));
+        }
+    };
+    template <typename VecD> struct SatCastHelper<2, VecD>
+    {
+        template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
         {
-            template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
-            {
-                typedef typename VecTraits<VecD>::elem_type D;
-                return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z));
-            }
-        };
-        template <typename VecD> struct SatCastHelper<4, VecD>
+            typedef typename VecTraits<VecD>::elem_type D;
+            return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y));
+        }
+    };
+    template <typename VecD> struct SatCastHelper<3, VecD>
+    {
+        template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
         {
-            template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
-            {
-                typedef typename VecTraits<VecD>::elem_type D;
-                return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z), saturate_cast<D>(v.w));
-            }
-        };
-
-        template <typename VecD, typename VecS> static __device__ __forceinline__ VecD saturate_cast_caller(const VecS& v)
+            typedef typename VecTraits<VecD>::elem_type D;
+            return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z));
+        }
+    };
+    template <typename VecD> struct SatCastHelper<4, VecD>
+    {
+        template <typename VecS> static __device__ __forceinline__ VecD cast(const VecS& v)
         {
-            return SatCastHelper<VecTraits<VecD>::cn, VecD>::cast(v);
+            typedef typename VecTraits<VecD>::elem_type D;
+            return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z), saturate_cast<D>(v.w));
         }
+    };
+
+    template <typename VecD, typename VecS> static __device__ __forceinline__ VecD saturate_cast_caller(const VecS& v)
+    {
+        return SatCastHelper<VecTraits<VecD>::cn, VecD>::cast(v);
     }
+}
 
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float1& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double1& v) {return detail::saturate_cast_caller<_Tp>(v);}
 
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float2& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double2& v) {return detail::saturate_cast_caller<_Tp>(v);}
 
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float3& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double3& v) {return detail::saturate_cast_caller<_Tp>(v);}
 
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float4& v) {return detail::saturate_cast_caller<_Tp>(v);}
-    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const double4& v) {return detail::saturate_cast_caller<_Tp>(v);}
 
 #define OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, op, func) \
     __device__ __forceinline__ TypeVec<func<type>::result_type, 1>::vec_type op(const type ## 1 & a) \
@@ -150,49 +150,49 @@ namespace cv {  namespace gpu { namespace device
         return VecTraits<TypeVec<func<type>::result_type, 4>::vec_type>::make(f(a.x), f(a.y), f(a.z), f(a.w)); \
     }
 
-    namespace detail
-    {    
-        template <typename T1, typename T2> struct BinOpTraits
-        {
-            typedef int argument_type;
-        };
-        template <typename T> struct BinOpTraits<T, T>
-        {
-            typedef T argument_type;
-        };
-        template <typename T> struct BinOpTraits<T, double>
-        {
-            typedef double argument_type;
-        };
-        template <typename T> struct BinOpTraits<double, T>
-        {
-            typedef double argument_type;
-        };
-        template <> struct BinOpTraits<double, double>
-        {
-            typedef double argument_type;
-        };
-        template <typename T> struct BinOpTraits<T, float>
-        {
-            typedef float argument_type;
-        };
-        template <typename T> struct BinOpTraits<float, T>
-        {
-            typedef float argument_type;
-        };
-        template <> struct BinOpTraits<float, float>
-        {
-            typedef float argument_type;
-        };
-        template <> struct BinOpTraits<double, float>
-        {
-            typedef double argument_type;
-        };
-        template <> struct BinOpTraits<float, double>
-        {
-            typedef double argument_type;
-        };
-    }
+namespace detail
+{    
+    template <typename T1, typename T2> struct BinOpTraits
+    {
+        typedef int argument_type;
+    };
+    template <typename T> struct BinOpTraits<T, T>
+    {
+        typedef T argument_type;
+    };
+    template <typename T> struct BinOpTraits<T, double>
+    {
+        typedef double argument_type;
+    };
+    template <typename T> struct BinOpTraits<double, T>
+    {
+        typedef double argument_type;
+    };
+    template <> struct BinOpTraits<double, double>
+    {
+        typedef double argument_type;
+    };
+    template <typename T> struct BinOpTraits<T, float>
+    {
+        typedef float argument_type;
+    };
+    template <typename T> struct BinOpTraits<float, T>
+    {
+        typedef float argument_type;
+    };
+    template <> struct BinOpTraits<float, float>
+    {
+        typedef float argument_type;
+    };
+    template <> struct BinOpTraits<double, float>
+    {
+        typedef double argument_type;
+    };
+    template <> struct BinOpTraits<float, double>
+    {
+        typedef double argument_type;
+    };
+}
 
 #define OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, op, func) \
     __device__ __forceinline__ TypeVec<func<type>::result_type, 1>::vec_type op(const type ## 1 & a, const type ## 1 & b) \
@@ -313,19 +313,20 @@ namespace cv {  namespace gpu { namespace device
     OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator ^, bit_xor) \
     OPENCV_GPU_IMPLEMENT_VEC_UNOP (type, operator ~, bit_not)
 
-    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(uchar)
-    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(char)
-    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(ushort)
-    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(short)
-    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(int)
-    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(uint)
-    OPENCV_GPU_IMPLEMENT_VEC_OP(float)
-    OPENCV_GPU_IMPLEMENT_VEC_OP(double)
+OPENCV_GPU_IMPLEMENT_VEC_INT_OP(uchar)
+OPENCV_GPU_IMPLEMENT_VEC_INT_OP(char)
+OPENCV_GPU_IMPLEMENT_VEC_INT_OP(ushort)
+OPENCV_GPU_IMPLEMENT_VEC_INT_OP(short)
+OPENCV_GPU_IMPLEMENT_VEC_INT_OP(int)
+OPENCV_GPU_IMPLEMENT_VEC_INT_OP(uint)
+OPENCV_GPU_IMPLEMENT_VEC_OP(float)
+OPENCV_GPU_IMPLEMENT_VEC_OP(double)
 
 #undef OPENCV_GPU_IMPLEMENT_VEC_UNOP
 #undef OPENCV_GPU_IMPLEMENT_VEC_BINOP
 #undef OPENCV_GPU_IMPLEMENT_VEC_OP
 #undef OPENCV_GPU_IMPLEMENT_VEC_INT_OP
-}}}
+
+END_OPENCV_DEVICE_NAMESPACE
         
 #endif // __OPENCV_GPU_VECMATH_HPP__
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp b/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp
index 52bba13bae22562bf7ef9d24c1c1fa6c671b4195..979da2aca2899de06fa0c27442006bd6f29da12d 100644
--- a/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp
@@ -45,82 +45,82 @@
 
 #include "internal_shared.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    template<typename T, int N> struct TypeVec;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    struct __align__(8) uchar8
-    {
-        uchar a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ uchar8 make_uchar8(uchar a0, uchar a1, uchar a2, uchar a3, uchar a4, uchar a5, uchar a6, uchar a7)
-    {
-        uchar8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct __align__(8) char8
-    {
-        schar a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ char8 make_char8(schar a0, schar a1, schar a2, schar a3, schar a4, schar a5, schar a6, schar a7)
-    {
-        char8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct __align__(16) ushort8
-    {
-        ushort a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ ushort8 make_ushort8(ushort a0, ushort a1, ushort a2, ushort a3, ushort a4, ushort a5, ushort a6, ushort a7)
-    {
-        ushort8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct __align__(16) short8
-    {
-        short a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ short8 make_short8(short a0, short a1, short a2, short a3, short a4, short a5, short a6, short a7)
-    {
-        short8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct __align__(32) uint8
-    {
-        uint a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ uint8 make_uint8(uint a0, uint a1, uint a2, uint a3, uint a4, uint a5, uint a6, uint a7)
-    {
-        uint8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct __align__(32) int8
-    {
-        int a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ int8 make_int8(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7)
-    {
-        int8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct __align__(32) float8
-    {
-        float a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ float8 make_float8(float a0, float a1, float a2, float a3, float a4, float a5, float a6, float a7)
-    {
-        float8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
-    struct double8
-    {
-        double a0, a1, a2, a3, a4, a5, a6, a7;
-    };
-    static __host__ __device__ __forceinline__ double8 make_double8(double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7)
-    {
-        double8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
-        return val;
-    }
+template<typename T, int N> struct TypeVec;
+
+struct __align__(8) uchar8
+{
+    uchar a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ uchar8 make_uchar8(uchar a0, uchar a1, uchar a2, uchar a3, uchar a4, uchar a5, uchar a6, uchar a7)
+{
+    uchar8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct __align__(8) char8
+{
+    schar a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ char8 make_char8(schar a0, schar a1, schar a2, schar a3, schar a4, schar a5, schar a6, schar a7)
+{
+    char8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct __align__(16) ushort8
+{
+    ushort a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ ushort8 make_ushort8(ushort a0, ushort a1, ushort a2, ushort a3, ushort a4, ushort a5, ushort a6, ushort a7)
+{
+    ushort8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct __align__(16) short8
+{
+    short a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ short8 make_short8(short a0, short a1, short a2, short a3, short a4, short a5, short a6, short a7)
+{
+    short8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct __align__(32) uint8
+{
+    uint a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ uint8 make_uint8(uint a0, uint a1, uint a2, uint a3, uint a4, uint a5, uint a6, uint a7)
+{
+    uint8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct __align__(32) int8
+{
+    int a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ int8 make_int8(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7)
+{
+    int8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct __align__(32) float8
+{
+    float a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ float8 make_float8(float a0, float a1, float a2, float a3, float a4, float a5, float a6, float a7)
+{
+    float8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
+struct double8
+{
+    double a0, a1, a2, a3, a4, a5, a6, a7;
+};
+static __host__ __device__ __forceinline__ double8 make_double8(double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7)
+{
+    double8 val = {a0, a1, a2, a3, a4, a5, a6, a7};
+    return val;
+}
 
 #define OPENCV_GPU_IMPLEMENT_TYPE_VEC(type) \
     template<> struct TypeVec<type, 1> { typedef type vec_type; }; \
@@ -134,28 +134,28 @@ namespace cv { namespace gpu { namespace device
     template<> struct TypeVec<type, 8> { typedef type ## 8 vec_type; }; \
     template<> struct TypeVec<type ## 8, 8> { typedef type ## 8 vec_type; };
 
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(uchar)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(char)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(ushort)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(short)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(int)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(uint)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(float)
-    OPENCV_GPU_IMPLEMENT_TYPE_VEC(double)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(uchar)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(char)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(ushort)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(short)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(int)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(uint)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(float)
+OPENCV_GPU_IMPLEMENT_TYPE_VEC(double)
 
 #undef OPENCV_GPU_IMPLEMENT_TYPE_VEC
 
-    template<> struct TypeVec<schar, 1> { typedef schar vec_type; };
-    template<> struct TypeVec<schar, 2> { typedef char2 vec_type; };
-    template<> struct TypeVec<schar, 3> { typedef char3 vec_type; };
-    template<> struct TypeVec<schar, 4> { typedef char4 vec_type; };
-    template<> struct TypeVec<schar, 8> { typedef char8 vec_type; };
+template<> struct TypeVec<schar, 1> { typedef schar vec_type; };
+template<> struct TypeVec<schar, 2> { typedef char2 vec_type; };
+template<> struct TypeVec<schar, 3> { typedef char3 vec_type; };
+template<> struct TypeVec<schar, 4> { typedef char4 vec_type; };
+template<> struct TypeVec<schar, 8> { typedef char8 vec_type; };
 
-    template<> struct TypeVec<bool, 1> { typedef uchar vec_type; };
-    template<> struct TypeVec<bool, 2> { typedef uchar2 vec_type; };
-    template<> struct TypeVec<bool, 3> { typedef uchar3 vec_type; };
-    template<> struct TypeVec<bool, 4> { typedef uchar4 vec_type; };
-    template<> struct TypeVec<bool, 8> { typedef uchar8 vec_type; };
+template<> struct TypeVec<bool, 1> { typedef uchar vec_type; };
+template<> struct TypeVec<bool, 2> { typedef uchar2 vec_type; };
+template<> struct TypeVec<bool, 3> { typedef uchar3 vec_type; };
+template<> struct TypeVec<bool, 4> { typedef uchar4 vec_type; };
+template<> struct TypeVec<bool, 8> { typedef uchar8 vec_type; };
 
     template<typename T> struct VecTraits;
 
@@ -209,72 +209,73 @@ namespace cv { namespace gpu { namespace device
         static __device__ __host__ __forceinline__ type ## 8 make(const type* v) {return make_ ## type ## 8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);} \
     };
 
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uchar)
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(ushort)
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(short)
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(int)
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uint)
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(float)
-    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(double)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uchar)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(ushort)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(short)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(int)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uint)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(float)
+OPENCV_GPU_IMPLEMENT_VEC_TRAITS(double)
 
 #undef OPENCV_GPU_IMPLEMENT_VEC_TRAITS
 
-    template<> struct VecTraits<char> 
-    { 
-        typedef char elem_type; 
-        enum {cn=1}; 
-        static __device__ __host__ __forceinline__ char all(char v) {return v;}
-        static __device__ __host__ __forceinline__ char make(char x) {return x;}
-        static __device__ __host__ __forceinline__ char make(const char* x) {return *x;}
-    };
-    template<> struct VecTraits<schar> 
-    { 
-        typedef schar elem_type; 
-        enum {cn=1}; 
-        static __device__ __host__ __forceinline__ schar all(schar v) {return v;}
-        static __device__ __host__ __forceinline__ schar make(schar x) {return x;}
-        static __device__ __host__ __forceinline__ schar make(const schar* x) {return *x;}
-    };
-    template<> struct VecTraits<char1>
-    {
-        typedef schar elem_type;
-        enum {cn=1};
-        static __device__ __host__ __forceinline__ char1 all(schar v) {return make_char1(v);}
-        static __device__ __host__ __forceinline__ char1 make(schar x) {return make_char1(x);}
-        static __device__ __host__ __forceinline__ char1 make(const schar* v) {return make_char1(v[0]);}
-    };
-    template<> struct VecTraits<char2>
-    {
-        typedef schar elem_type;
-        enum {cn=2};
-        static __device__ __host__ __forceinline__ char2 all(schar v) {return make_char2(v, v);}
-        static __device__ __host__ __forceinline__ char2 make(schar x, schar y) {return make_char2(x, y);}
-        static __device__ __host__ __forceinline__ char2 make(const schar* v) {return make_char2(v[0], v[1]);}
-    };
-    template<> struct VecTraits<char3>
-    {
-        typedef schar elem_type;
-        enum {cn=3};
-        static __device__ __host__ __forceinline__ char3 all(schar v) {return make_char3(v, v, v);}
-        static __device__ __host__ __forceinline__ char3 make(schar x, schar y, schar z) {return make_char3(x, y, z);}
-        static __device__ __host__ __forceinline__ char3 make(const schar* v) {return make_char3(v[0], v[1], v[2]);}
-    };
-    template<> struct VecTraits<char4>
-    {
-        typedef schar elem_type;
-        enum {cn=4};
-        static __device__ __host__ __forceinline__ char4 all(schar v) {return make_char4(v, v, v, v);}
-        static __device__ __host__ __forceinline__ char4 make(schar x, schar y, schar z, schar w) {return make_char4(x, y, z, w);}
-        static __device__ __host__ __forceinline__ char4 make(const schar* v) {return make_char4(v[0], v[1], v[2], v[3]);}
-    };
-    template<> struct VecTraits<char8>
-    {
-        typedef schar elem_type;
-        enum {cn=8};
-        static __device__ __host__ __forceinline__ char8 all(schar v) {return make_char8(v, v, v, v, v, v, v, v);}
-        static __device__ __host__ __forceinline__ char8 make(schar a0, schar a1, schar a2, schar a3, schar a4, schar a5, schar a6, schar a7) {return make_char8(a0, a1, a2, a3, a4, a5, a6, a7);}
-        static __device__ __host__ __forceinline__ char8 make(const schar* v) {return make_char8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);}
-    };
-}}}
+template<> struct VecTraits<char> 
+{ 
+    typedef char elem_type; 
+    enum {cn=1}; 
+    static __device__ __host__ __forceinline__ char all(char v) {return v;}
+    static __device__ __host__ __forceinline__ char make(char x) {return x;}
+    static __device__ __host__ __forceinline__ char make(const char* x) {return *x;}
+};
+template<> struct VecTraits<schar> 
+{ 
+    typedef schar elem_type; 
+    enum {cn=1}; 
+    static __device__ __host__ __forceinline__ schar all(schar v) {return v;}
+    static __device__ __host__ __forceinline__ schar make(schar x) {return x;}
+    static __device__ __host__ __forceinline__ schar make(const schar* x) {return *x;}
+};
+template<> struct VecTraits<char1>
+{
+    typedef schar elem_type;
+    enum {cn=1};
+    static __device__ __host__ __forceinline__ char1 all(schar v) {return make_char1(v);}
+    static __device__ __host__ __forceinline__ char1 make(schar x) {return make_char1(x);}
+    static __device__ __host__ __forceinline__ char1 make(const schar* v) {return make_char1(v[0]);}
+};
+template<> struct VecTraits<char2>
+{
+    typedef schar elem_type;
+    enum {cn=2};
+    static __device__ __host__ __forceinline__ char2 all(schar v) {return make_char2(v, v);}
+    static __device__ __host__ __forceinline__ char2 make(schar x, schar y) {return make_char2(x, y);}
+    static __device__ __host__ __forceinline__ char2 make(const schar* v) {return make_char2(v[0], v[1]);}
+};
+template<> struct VecTraits<char3>
+{
+    typedef schar elem_type;
+    enum {cn=3};
+    static __device__ __host__ __forceinline__ char3 all(schar v) {return make_char3(v, v, v);}
+    static __device__ __host__ __forceinline__ char3 make(schar x, schar y, schar z) {return make_char3(x, y, z);}
+    static __device__ __host__ __forceinline__ char3 make(const schar* v) {return make_char3(v[0], v[1], v[2]);}
+};
+template<> struct VecTraits<char4>
+{
+    typedef schar elem_type;
+    enum {cn=4};
+    static __device__ __host__ __forceinline__ char4 all(schar v) {return make_char4(v, v, v, v);}
+    static __device__ __host__ __forceinline__ char4 make(schar x, schar y, schar z, schar w) {return make_char4(x, y, z, w);}
+    static __device__ __host__ __forceinline__ char4 make(const schar* v) {return make_char4(v[0], v[1], v[2], v[3]);}
+};
+template<> struct VecTraits<char8>
+{
+    typedef schar elem_type;
+    enum {cn=8};
+    static __device__ __host__ __forceinline__ char8 all(schar v) {return make_char8(v, v, v, v, v, v, v, v);}
+    static __device__ __host__ __forceinline__ char8 make(schar a0, schar a1, schar a2, schar a3, schar a4, schar a5, schar a6, schar a7) {return make_char8(a0, a1, a2, a3, a4, a5, a6, a7);}
+    static __device__ __host__ __forceinline__ char8 make(const schar* v) {return make_char8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);}
+};
+
+END_OPENCV_DEVICE_NAMESPACE
 
 #endif // __OPENCV_GPU_VEC_TRAITS_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/warp.hpp b/modules/gpu/src/opencv2/gpu/device/warp.hpp
index cd9baf27c8c84eb89169c6e6587758853478df7c..9abe6e4de10b479b20f8508d4152bbdef68d75e7 100644
--- a/modules/gpu/src/opencv2/gpu/device/warp.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/warp.hpp
@@ -40,79 +40,76 @@
 //
 //M*/
 
-#ifndef __OPENCV_GPU_DEVICE_WARP_HPP_
-#define __OPENCV_GPU_DEVICE_WARP_HPP_
+#ifndef __OPENCV_GPU_DEVICE_WARP_HPP__
+#define __OPENCV_GPU_DEVICE_WARP_HPP__
 
-namespace cv
+#include "internal_shared.hpp"
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+struct Warp
 {
-    namespace gpu
+    enum
     {
-        namespace device
-        {
-            struct Warp
-            {
-                enum
-                {
-                    LOG_WARP_SIZE = 5,
-                    WARP_SIZE     = 1 << LOG_WARP_SIZE,
-                    STRIDE        = WARP_SIZE
-                };
+        LOG_WARP_SIZE = 5,
+        WARP_SIZE     = 1 << LOG_WARP_SIZE,
+        STRIDE        = WARP_SIZE
+    };
 
-                /** \brief Returns the warp lane ID of the calling thread. */
-                static __device__ __forceinline__ unsigned int laneId()
-                {
-                    unsigned int ret;
-                    asm("mov.u32 %0, %laneid;" : "=r"(ret) );
-                    return ret;
-                }
+    /** \brief Returns the warp lane ID of the calling thread. */
+    static __device__ __forceinline__ unsigned int laneId()
+    {
+        unsigned int ret;
+        asm("mov.u32 %0, %laneid;" : "=r"(ret) );
+        return ret;
+    }
 
-                template<typename It, typename T>
-                static __device__ __forceinline__ void fill(It beg, It end, const T& value)
-                {                
-                    for(It t = beg + laneId(); t < end; t += STRIDE)
-                        *t = value;
-                }            
+    template<typename It, typename T>
+    static __device__ __forceinline__ void fill(It beg, It end, const T& value)
+    {                
+        for(It t = beg + laneId(); t < end; t += STRIDE)
+            *t = value;
+    }            
 
-                template<typename InIt, typename OutIt>
-                static __device__ __forceinline__ OutIt copy(InIt beg, InIt end, OutIt out)
-                {                
-                    for(InIt t = beg + laneId(); t < end; t += STRIDE, out += STRIDE)
-                        *out = *t;
-                    return out;
-                }            
+    template<typename InIt, typename OutIt>
+    static __device__ __forceinline__ OutIt copy(InIt beg, InIt end, OutIt out)
+    {                
+        for(InIt t = beg + laneId(); t < end; t += STRIDE, out += STRIDE)
+            *out = *t;
+        return out;
+    }            
 
-                template<typename InIt, typename OutIt, class UnOp>
-                static __device__ __forceinline__ OutIt transform(InIt beg, InIt end, OutIt out, UnOp op)
-                {
-                    for(InIt t = beg + laneId(); t < end; t += STRIDE, out += STRIDE)
-                        *out = op(*t);
-                    return out;
-                }
+    template<typename InIt, typename OutIt, class UnOp>
+    static __device__ __forceinline__ OutIt transform(InIt beg, InIt end, OutIt out, UnOp op)
+    {
+        for(InIt t = beg + laneId(); t < end; t += STRIDE, out += STRIDE)
+            *out = op(*t);
+        return out;
+    }
 
-                template<typename InIt1, typename InIt2, typename OutIt, class BinOp>
-                static __device__ __forceinline__ OutIt transform(InIt1 beg1, InIt1 end1, InIt2 beg2, OutIt out, BinOp op)
-                {
-                    unsigned int lane = laneId();
+    template<typename InIt1, typename InIt2, typename OutIt, class BinOp>
+    static __device__ __forceinline__ OutIt transform(InIt1 beg1, InIt1 end1, InIt2 beg2, OutIt out, BinOp op)
+    {
+        unsigned int lane = laneId();
 
-                    InIt1 t1 = beg1 + lane; 
-                    InIt2 t2 = beg2 + lane;
-                    for(; t1 < end1; t1 += STRIDE, t2 += STRIDE, out += STRIDE)
-                        *out = op(*t1, *t2);
-                    return out;
-                }
+        InIt1 t1 = beg1 + lane; 
+        InIt2 t2 = beg2 + lane;
+        for(; t1 < end1; t1 += STRIDE, t2 += STRIDE, out += STRIDE)
+            *out = op(*t1, *t2);
+        return out;
+    }
 
-                template<typename OutIt, typename T>
-                static __device__ __forceinline__ void yota(OutIt beg, OutIt end, T value)
-                {
-                    unsigned int lane = laneId();                
-                    value += lane;
+    template<typename OutIt, typename T>
+    static __device__ __forceinline__ void yota(OutIt beg, OutIt end, T value)
+    {
+        unsigned int lane = laneId();                
+        value += lane;
 
-                    for(OutIt t = beg + lane; t < end; t += STRIDE, value += STRIDE)
-                        *t = value;
-                }
-            };
-        }
+        for(OutIt t = beg + lane; t < end; t += STRIDE, value += STRIDE)
+            *t = value;
     }
-}
+};
+
+END_OPENCV_DEVICE_NAMESPACE
 
-#endif /* __OPENCV_GPU_DEVICE_WARP_HPP_ */
\ No newline at end of file
+#endif /* __OPENCV_GPU_DEVICE_WARP_HPP__ */
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/warp_reduce.hpp b/modules/gpu/src/opencv2/gpu/device/warp_reduce.hpp
index 2368676084f020a0dd16262ced15a74d3ba7b62c..91602df6f01f11fb098ffce0a7b45e1b61228b08 100644
--- a/modules/gpu/src/opencv2/gpu/device/warp_reduce.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/warp_reduce.hpp
@@ -41,33 +41,32 @@
 //M*/
 
 
-#ifndef OPENCV_GPU_WARP_REDUCE_HPP_
-#define OPENCV_GPU_WARP_REDUCE_HPP_
+#ifndef OPENCV_GPU_WARP_REDUCE_HPP__
+#define OPENCV_GPU_WARP_REDUCE_HPP__
 
+#include "internal_shared.hpp"
 
-namespace cv
+BEGIN_OPENCV_DEVICE_NAMESPACE
+		
+template <class T> 
+__device__ __forceinline__ T warp_reduce ( volatile T *ptr , const unsigned int tid = threadIdx.x )
 {
-	namespace device
-	{		
-		 template <class T> 
-        __device__ __forceinline__ T warp_reduce ( volatile T *ptr , const unsigned int tid = threadIdx.x )
-        {
-            const unsigned int lane = tid & 31; // index of thread in warp (0..31)
-						
-			if (lane < 16)
-			{				
-				T partial = ptr[tid];
+    const unsigned int lane = tid & 31; // index of thread in warp (0..31)
+				
+	if (lane < 16)
+	{				
+		T partial = ptr[tid];
 
-				ptr[tid] = partial = partial + ptr[tid + 16];
-				ptr[tid] = partial = partial + ptr[tid + 8];
-				ptr[tid] = partial = partial + ptr[tid + 4];
-				ptr[tid] = partial = partial + ptr[tid + 2];
-				ptr[tid] = partial = partial + ptr[tid + 1];            
-			}
-			return ptr[tid - lane];
-
-        }
+		ptr[tid] = partial = partial + ptr[tid + 16];
+		ptr[tid] = partial = partial + ptr[tid + 8];
+		ptr[tid] = partial = partial + ptr[tid + 4];
+		ptr[tid] = partial = partial + ptr[tid + 2];
+		ptr[tid] = partial = partial + ptr[tid + 1];            
 	}
+
+	return ptr[tid - lane];
 }
 
-#endif /* OPENCV_GPU_WARP_REDUCE_HPP_ */
\ No newline at end of file
+END_OPENCV_DEVICE_NAMESPACE
+
+#endif /* OPENCV_GPU_WARP_REDUCE_HPP__ */
\ No newline at end of file
diff --git a/modules/gpu/src/split_merge.cpp b/modules/gpu/src/split_merge.cpp
index a7918624ac7a9591a95f12959238ed922518e90e..4d05ee913970698afbc3bf30d6a6246910fd0c6d 100644
--- a/modules/gpu/src/split_merge.cpp
+++ b/modules/gpu/src/split_merge.cpp
@@ -42,6 +42,8 @@
 
 #include "precomp.hpp"
 
+using namespace cv;
+using namespace cv::gpu;
 using namespace std;
 
 #if !defined (HAVE_CUDA)
@@ -53,24 +55,24 @@ void cv::gpu::split(const GpuMat& /*src*/, vector<GpuMat>& /*dst*/, Stream& /*st
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace split_merge 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace split_merge 
 {    
-    extern "C" void merge_caller(const DevMem2Db* src, DevMem2Db& dst, 
-                                 int total_channels, size_t elem_size, 
-                                 const cudaStream_t& stream);
+    void merge_caller(const DevMem2Db* src, DevMem2Db& dst, int total_channels, size_t elem_size, const cudaStream_t& stream);
+    void split_caller(const DevMem2Db& src, DevMem2Db* dst, int num_channels, size_t elem_size1, const cudaStream_t& stream);
+}
 
-    extern "C" void split_caller(const DevMem2Db& src, DevMem2Db* dst, 
-                                 int num_channels, size_t elem_size1, 
-                                 const cudaStream_t& stream);
+END_OPENCV_DEVICE_NAMESPACE
 
+namespace
+{
     void merge(const GpuMat* src, size_t n, GpuMat& dst, const cudaStream_t& stream) 
     {
+        using namespace OPENCV_DEVICE_NAMESPACE_ split_merge;
+
         CV_Assert(src);
         CV_Assert(n > 0);
-       
-        bool double_ok = TargetArchs::builtWith(NATIVE_DOUBLE) && 
-                         DeviceInfo().supports(NATIVE_DOUBLE);
-        CV_Assert(src[0].depth() != CV_64F || double_ok);
 
         int depth = src[0].depth();
         Size size = src[0].size();
@@ -100,20 +102,15 @@ namespace cv { namespace gpu { namespace split_merge
                 src_as_devmem[i] = src[i];
 
             DevMem2Db dst_as_devmem(dst);
-            split_merge::merge_caller(src_as_devmem, dst_as_devmem,
-                                      total_channels, CV_ELEM_SIZE(depth),
-                                      stream);
+            merge_caller(src_as_devmem, dst_as_devmem, total_channels, CV_ELEM_SIZE(depth), stream);
         }   
     }
 
-
     void split(const GpuMat& src, GpuMat* dst, const cudaStream_t& stream) 
     {
-        CV_Assert(dst);
+        using namespace OPENCV_DEVICE_NAMESPACE_ split_merge;
 
-        bool double_ok = TargetArchs::builtWith(NATIVE_DOUBLE) && 
-                         DeviceInfo().supports(NATIVE_DOUBLE);
-        CV_Assert(src.depth() != CV_64F || double_ok);
+        CV_Assert(dst);
 
         int depth = src.depth();
         int num_channels = src.channels();
@@ -135,38 +132,31 @@ namespace cv { namespace gpu { namespace split_merge
             dst_as_devmem[i] = dst[i];
 
         DevMem2Db src_as_devmem(src);
-        split_merge::split_caller(src_as_devmem, dst_as_devmem,
-                                  num_channels, src.elemSize1(), 
-                                  stream);
+        split_caller(src_as_devmem, dst_as_devmem, num_channels, src.elemSize1(), stream);
     }
-
-
-}}}
-
+}
 
 void cv::gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream) 
 { 
-    split_merge::merge(src, n, dst, StreamAccessor::getStream(stream));
+    ::merge(src, n, dst, StreamAccessor::getStream(stream));
 }
 
 
 void cv::gpu::merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream) 
 {
-    split_merge::merge(&src[0], src.size(), dst, StreamAccessor::getStream(stream));
+    ::merge(&src[0], src.size(), dst, StreamAccessor::getStream(stream));
 }
 
-
 void cv::gpu::split(const GpuMat& src, GpuMat* dst, Stream& stream) 
 {
-    split_merge::split(src, dst, StreamAccessor::getStream(stream));
+    ::split(src, dst, StreamAccessor::getStream(stream));
 }
 
-
 void cv::gpu::split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream) 
 {
     dst.resize(src.channels());
     if(src.channels() > 0)
-        split_merge::split(src, &dst[0], StreamAccessor::getStream(stream));
+        ::split(src, &dst[0], StreamAccessor::getStream(stream));
 }
 
 #endif /* !defined (HAVE_CUDA) */
diff --git a/modules/gpu/src/stereobm.cpp b/modules/gpu/src/stereobm.cpp
index 8ab2d297952466cb74408a76e0d13e2e05348b48..974b3dc2e8729a5f3dcba85a93dd85051de791ae 100644
--- a/modules/gpu/src/stereobm.cpp
+++ b/modules/gpu/src/stereobm.cpp
@@ -55,21 +55,23 @@ void cv::gpu::StereoBM_GPU::operator() ( const GpuMat&, const GpuMat&, GpuMat&,
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace stereobm
 {
-    namespace bm
-    {
-        //extern "C" void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int ndisp, int winsz, const DevMem2D_<uint>& minSSD_buf);
-        extern "C" void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int ndisp, int winsz, const DevMem2D_<uint>& minSSD_buf, cudaStream_t & stream);
-        extern "C" void prefilter_xsobel(const DevMem2Db& input, const DevMem2Db& output, int prefilterCap /*= 31*/, cudaStream_t & stream);
-        extern "C" void postfilter_textureness(const DevMem2Db& input, int winsz, float avgTexturenessThreshold, const DevMem2Db& disp, cudaStream_t & stream);
-    }
-}}
+    void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int ndisp, int winsz, const DevMem2D_<uint>& minSSD_buf, cudaStream_t & stream);
+    void prefilter_xsobel(const DevMem2Db& input, const DevMem2Db& output, int prefilterCap /*= 31*/, cudaStream_t & stream);
+    void postfilter_textureness(const DevMem2Db& input, int winsz, float avgTexturenessThreshold, const DevMem2Db& disp, cudaStream_t & stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
 const float defaultAvgTexThreshold = 3;
 
 cv::gpu::StereoBM_GPU::StereoBM_GPU()
-    : preset(BASIC_PRESET), ndisp(DEFAULT_NDISP), winSize(DEFAULT_WINSZ), avergeTexThreshold(defaultAvgTexThreshold)  {}
+    : preset(BASIC_PRESET), ndisp(DEFAULT_NDISP), winSize(DEFAULT_WINSZ), avergeTexThreshold(defaultAvgTexThreshold)  
+{
+}
 
 cv::gpu::StereoBM_GPU::StereoBM_GPU(int preset_, int ndisparities_, int winSize_)
     : preset(preset_), ndisp(ndisparities_), winSize(winSize_), avergeTexThreshold(defaultAvgTexThreshold)
@@ -93,39 +95,44 @@ bool cv::gpu::StereoBM_GPU::checkIfGpuCallReasonable()
     return false;
 }
 
-static void stereo_bm_gpu_operator ( GpuMat& minSSD,  GpuMat& leBuf, GpuMat&  riBuf,  int preset, int ndisp, int winSize, float avergeTexThreshold, const GpuMat& left, const GpuMat& right, GpuMat& disparity, cudaStream_t stream)
+namespace
 {
-    CV_DbgAssert(left.rows == right.rows && left.cols == right.cols);
-    CV_DbgAssert(left.type() == CV_8UC1);
-    CV_DbgAssert(right.type() == CV_8UC1);
+    void stereo_bm_gpu_operator( GpuMat& minSSD,  GpuMat& leBuf, GpuMat&  riBuf,  int preset, int ndisp, int winSize, float avergeTexThreshold, const GpuMat& left, const GpuMat& right, GpuMat& disparity, cudaStream_t stream)
+    {
+        using namespace OPENCV_DEVICE_NAMESPACE_ stereobm;
 
-    disparity.create(left.size(), CV_8U);
-    minSSD.create(left.size(), CV_32S);
+        CV_DbgAssert(left.rows == right.rows && left.cols == right.cols);
+        CV_DbgAssert(left.type() == CV_8UC1);
+        CV_DbgAssert(right.type() == CV_8UC1);
 
-    GpuMat le_for_bm =  left;
-    GpuMat ri_for_bm = right;
+        disparity.create(left.size(), CV_8U);
+        minSSD.create(left.size(), CV_32S);
 
-    if (preset == StereoBM_GPU::PREFILTER_XSOBEL)
-    {
-        leBuf.create( left.size(),  left.type());
-        riBuf.create(right.size(), right.type());
+        GpuMat le_for_bm =  left;
+        GpuMat ri_for_bm = right;
 
-		bm::prefilter_xsobel( left, leBuf, 31, stream);
-        bm::prefilter_xsobel(right, riBuf, 31, stream);
+        if (preset == StereoBM_GPU::PREFILTER_XSOBEL)
+        {
+            leBuf.create( left.size(),  left.type());
+            riBuf.create(right.size(), right.type());
 
-        le_for_bm = leBuf;
-        ri_for_bm = riBuf;
-    }
+		    prefilter_xsobel( left, leBuf, 31, stream);
+            prefilter_xsobel(right, riBuf, 31, stream);
+
+            le_for_bm = leBuf;
+            ri_for_bm = riBuf;
+        }
 
-    bm::stereoBM_GPU(le_for_bm, ri_for_bm, disparity, ndisp, winSize, minSSD, stream);
+        stereoBM_GPU(le_for_bm, ri_for_bm, disparity, ndisp, winSize, minSSD, stream);
 
-    if (avergeTexThreshold)
-        bm::postfilter_textureness(le_for_bm, winSize, avergeTexThreshold, disparity, stream);
+        if (avergeTexThreshold)
+            postfilter_textureness(le_for_bm, winSize, avergeTexThreshold, disparity, stream);
+    }
 }
 
 void cv::gpu::StereoBM_GPU::operator() ( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream)
 {
-    ::stereo_bm_gpu_operator(minSSD, leBuf, riBuf, preset, ndisp, winSize, avergeTexThreshold, left, right, disparity, StreamAccessor::getStream(stream));
+    stereo_bm_gpu_operator(minSSD, leBuf, riBuf, preset, ndisp, winSize, avergeTexThreshold, left, right, disparity, StreamAccessor::getStream(stream));
 }
 
 #endif /* !defined (HAVE_CUDA) */
diff --git a/modules/gpu/src/stereobp.cpp b/modules/gpu/src/stereobp.cpp
index 288e2f8c236ba0a7a5f9f20974ad1b8dacaf214d..7cc960a177e9934824f265e8bd021ac5743bdf58 100644
--- a/modules/gpu/src/stereobp.cpp
+++ b/modules/gpu/src/stereobp.cpp
@@ -59,7 +59,9 @@ void cv::gpu::StereoBeliefPropagation::operator()(const GpuMat&, GpuMat&, Stream
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace bp
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace stereobp
 {
     void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump);
     template<typename T, typename D>
@@ -74,7 +76,11 @@ namespace cv { namespace gpu { namespace bp
     template <typename T>
     void output_gpu(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, 
         const DevMem2D_<short>& disp, cudaStream_t stream);
-}}}
+}
+
+END_OPENCV_DEVICE_NAMESPACE
+
+using namespace OPENCV_DEVICE_NAMESPACE_ stereobp;
 
 namespace
 {
@@ -84,7 +90,6 @@ namespace
     const float DEFAULT_DISC_SINGLE_JUMP = 1.0f;
 }
 
-
 void cv::gpu::StereoBeliefPropagation::estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels)
 {
     ndisp = width / 4;
@@ -136,8 +141,8 @@ namespace
             typedef void (*comp_data_t)(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream);
             static const comp_data_t comp_data_callers[2][5] = 
             {
-                {0, bp::comp_data_gpu<unsigned char, short>, 0, bp::comp_data_gpu<uchar3, short>, bp::comp_data_gpu<uchar4, short>},
-                {0, bp::comp_data_gpu<unsigned char, float>, 0, bp::comp_data_gpu<uchar3, float>, bp::comp_data_gpu<uchar4, float>}
+                {0, comp_data_gpu<unsigned char, short>, 0, comp_data_gpu<uchar3, short>, comp_data_gpu<uchar4, short>},
+                {0, comp_data_gpu<unsigned char, float>, 0, comp_data_gpu<uchar3, float>, comp_data_gpu<uchar4, float>}
             };
 
             CV_Assert(left.size() == right.size() && left.type() == right.type());
@@ -236,7 +241,7 @@ namespace
                 }
             }
 
-            bp::load_constants(rthis.ndisp, rthis.max_data_term, scale * rthis.data_weight, scale * rthis.max_disc_term, scale * rthis.disc_single_jump);
+            load_constants(rthis.ndisp, rthis.max_data_term, scale * rthis.data_weight, scale * rthis.max_disc_term, scale * rthis.disc_single_jump);
 
             datas.resize(rthis.levels);
 
@@ -249,8 +254,6 @@ namespace
 
         void calcBP(GpuMat& disp, Stream& stream)
         {
-            using namespace cv::gpu::bp;
-
             typedef void (*data_step_down_t)(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
             static const data_step_down_t data_step_down_callers[2] = 
             {
@@ -354,13 +357,13 @@ namespace
 
 void cv::gpu::StereoBeliefPropagation::operator()(const GpuMat& left, const GpuMat& right, GpuMat& disp, Stream& stream)
 {
-    ::StereoBeliefPropagationImpl impl(*this, u, d, l, r, u2, d2, l2, r2, datas, out);
+    StereoBeliefPropagationImpl impl(*this, u, d, l, r, u2, d2, l2, r2, datas, out);
     impl(left, right, disp, stream);
 }
 
 void cv::gpu::StereoBeliefPropagation::operator()(const GpuMat& data, GpuMat& disp, Stream& stream)
 {
-    ::StereoBeliefPropagationImpl impl(*this, u, d, l, r, u2, d2, l2, r2, datas, out);
+    StereoBeliefPropagationImpl impl(*this, u, d, l, r, u2, d2, l2, r2, datas, out);
     impl(data, disp, stream);
 }
 
diff --git a/modules/gpu/src/stereocsbp.cpp b/modules/gpu/src/stereocsbp.cpp
index 85faaf8c0d01823cc40f2865ac156ad5050943e6..a0c8a7f7a622ba9c1409f67d076373733c3fa01d 100644
--- a/modules/gpu/src/stereocsbp.cpp
+++ b/modules/gpu/src/stereocsbp.cpp
@@ -57,7 +57,9 @@ void cv::gpu::StereoConstantSpaceBP::operator()(const GpuMat&, const GpuMat&, Gp
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace csbp
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace stereocsbp
 {
     void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th,
         const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& temp);
@@ -84,8 +86,11 @@ namespace cv { namespace gpu { namespace csbp
     template<class T> 
     void compute_disp(const T* u, const T* d, const T* l, const T* r, const T* data_cost_selected, const T* disp_selected, size_t msg_step,
         const DevMem2D_<short>& disp, int nr_plane, cudaStream_t stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE
 
-}}}
+using namespace OPENCV_DEVICE_NAMESPACE_ stereocsbp;
 
 namespace
 {
@@ -208,8 +213,7 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2]
     ////////////////////////////////////////////////////////////////////////////
     // Compute
 
-    csbp::load_constants(rthis.ndisp, rthis.max_data_term, rthis.data_weight,
-        rthis.max_disc_term, rthis.disc_single_jump, rthis.min_disp_th, left, right, temp);
+    load_constants(rthis.ndisp, rthis.max_data_term, rthis.data_weight, rthis.max_disc_term, rthis.disc_single_jump, rthis.min_disp_th, left, right, temp);
 
     if (stream)
     {
@@ -248,28 +252,28 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2]
     {
         if (i == levels - 1)
         {
-            csbp::init_data_cost(left.rows, left.cols, disp_selected_pyr[cur_idx].ptr<T>(), data_cost_selected.ptr<T>(),
+            init_data_cost(left.rows, left.cols, disp_selected_pyr[cur_idx].ptr<T>(), data_cost_selected.ptr<T>(),
                 step_pyr[i], rows_pyr[i], cols_pyr[i], i, nr_plane_pyr[i], rthis.ndisp, left.channels(), rthis.use_local_init_data_cost, cudaStream);
         }
         else
         {
-            csbp::compute_data_cost(disp_selected_pyr[cur_idx].ptr<T>(), data_cost.ptr<T>(), step_pyr[i], step_pyr[i+1],
+            compute_data_cost(disp_selected_pyr[cur_idx].ptr<T>(), data_cost.ptr<T>(), step_pyr[i], step_pyr[i+1],
                 left.rows, left.cols, rows_pyr[i], cols_pyr[i], rows_pyr[i+1], i, nr_plane_pyr[i+1], left.channels(), cudaStream);
 
             int new_idx = (cur_idx + 1) & 1;
 
-            csbp::init_message(u[new_idx].ptr<T>(), d[new_idx].ptr<T>(), l[new_idx].ptr<T>(), r[new_idx].ptr<T>(),
-                               u[cur_idx].ptr<T>(), d[cur_idx].ptr<T>(), l[cur_idx].ptr<T>(), r[cur_idx].ptr<T>(),
-                               disp_selected_pyr[new_idx].ptr<T>(), disp_selected_pyr[cur_idx].ptr<T>(),
-                               data_cost_selected.ptr<T>(), data_cost.ptr<T>(), step_pyr[i], step_pyr[i+1], rows_pyr[i],
-                               cols_pyr[i], nr_plane_pyr[i], rows_pyr[i+1], cols_pyr[i+1], nr_plane_pyr[i+1], cudaStream);
+            init_message(u[new_idx].ptr<T>(), d[new_idx].ptr<T>(), l[new_idx].ptr<T>(), r[new_idx].ptr<T>(),
+                         u[cur_idx].ptr<T>(), d[cur_idx].ptr<T>(), l[cur_idx].ptr<T>(), r[cur_idx].ptr<T>(),
+                         disp_selected_pyr[new_idx].ptr<T>(), disp_selected_pyr[cur_idx].ptr<T>(),
+                         data_cost_selected.ptr<T>(), data_cost.ptr<T>(), step_pyr[i], step_pyr[i+1], rows_pyr[i],
+                         cols_pyr[i], nr_plane_pyr[i], rows_pyr[i+1], cols_pyr[i+1], nr_plane_pyr[i+1], cudaStream);
 
             cur_idx = new_idx;
         }
 
-        csbp::calc_all_iterations(u[cur_idx].ptr<T>(), d[cur_idx].ptr<T>(), l[cur_idx].ptr<T>(), r[cur_idx].ptr<T>(),
-                                  data_cost_selected.ptr<T>(), disp_selected_pyr[cur_idx].ptr<T>(), step_pyr[i],
-                                  rows_pyr[i], cols_pyr[i], nr_plane_pyr[i], rthis.iters, cudaStream);
+        calc_all_iterations(u[cur_idx].ptr<T>(), d[cur_idx].ptr<T>(), l[cur_idx].ptr<T>(), r[cur_idx].ptr<T>(),
+                            data_cost_selected.ptr<T>(), disp_selected_pyr[cur_idx].ptr<T>(), step_pyr[i],
+                            rows_pyr[i], cols_pyr[i], nr_plane_pyr[i], rthis.iters, cudaStream);
     }
 
     if (disp.empty())
@@ -282,8 +286,8 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2]
     else
         out.setTo(zero);
 
-    csbp::compute_disp(u[cur_idx].ptr<T>(), d[cur_idx].ptr<T>(), l[cur_idx].ptr<T>(), r[cur_idx].ptr<T>(),
-                       data_cost_selected.ptr<T>(), disp_selected_pyr[cur_idx].ptr<T>(), step_pyr[0], out, nr_plane_pyr[0], cudaStream);
+    compute_disp(u[cur_idx].ptr<T>(), d[cur_idx].ptr<T>(), l[cur_idx].ptr<T>(), r[cur_idx].ptr<T>(),
+                 data_cost_selected.ptr<T>(), disp_selected_pyr[cur_idx].ptr<T>(), step_pyr[0], out, nr_plane_pyr[0], cudaStream);
 
     if (disp.type() != CV_16S)
     {
diff --git a/modules/gpu/src/surf.cpp b/modules/gpu/src/surf.cpp
index dba969646f03cebda6359ba3d9be912a154fa92b..35128448d99e8d3abdd4b4795ab8603bc38b7430 100644
--- a/modules/gpu/src/surf.cpp
+++ b/modules/gpu/src/surf.cpp
@@ -63,8 +63,17 @@ void cv::gpu::SURF_GPU::releaseMemory() { throw_nogpu(); }
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace surf
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace surf
 {
+    void loadGlobalConstants(int maxCandidates, int maxFeatures, int img_rows, int img_cols, int nOctaveLayers, float hessianThreshold);
+    void loadOctaveConstants(int octave, int layer_rows, int layer_cols);
+
+    void bindImgTex(DevMem2Db img);
+    void bindSumTex(DevMem2D_<uint> sum);
+    void bindMaskSumTex(DevMem2D_<uint> maskSum);
+
     void icvCalcLayerDetAndTrace_gpu(const PtrStepf& det, const PtrStepf& trace, int img_rows, int img_cols, int octave, int nOctaveLayers);
 
     void icvFindMaximaInLayer_gpu(const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
@@ -78,9 +87,11 @@ namespace cv { namespace gpu { namespace surf
 
     void compute_descriptors_gpu(const DevMem2Df& descriptors, 
         const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures);
-}}}
+}
 
-using namespace cv::gpu::surf;
+END_OPENCV_DEVICE_NAMESPACE
+
+using namespace OPENCV_DEVICE_NAMESPACE_ surf;
 
 namespace
 {
@@ -136,24 +147,18 @@ namespace
             counters.create(1, nOctaves + 1, CV_32SC1);
             counters.setTo(Scalar::all(0));
 
-            uploadConstant("cv::gpu::surf::c_max_candidates",    maxCandidates);
-            uploadConstant("cv::gpu::surf::c_max_features",      maxFeatures);
-            uploadConstant("cv::gpu::surf::c_img_rows",          img_rows);
-            uploadConstant("cv::gpu::surf::c_img_cols",          img_cols);
-            uploadConstant("cv::gpu::surf::c_nOctaveLayers",     nOctaveLayers);
-            uploadConstant("cv::gpu::surf::c_hessianThreshold",  static_cast<float>(hessianThreshold));
+            loadGlobalConstants(maxCandidates, maxFeatures, img_rows, img_cols, nOctaveLayers, static_cast<float>(hessianThreshold));
 
-            imgTex.bind("cv::gpu::surf::imgTex", (DevMem2Db)img);
+            bindImgTex(img);
 
             integralBuffered(img, sum, intBuffer);
-            sumTex.bind("cv::gpu::surf::sumTex", (DevMem2D_<unsigned int>)sum);
+            bindSumTex(sum);
 
             if (use_mask)
             {
                 min(mask, 1.0, mask1);
                 integralBuffered(mask1, maskSum, intBuffer);
-
-                maskSumTex.bind("cv::gpu::surf::maskSumTex", (DevMem2D_<unsigned int>)maskSum);
+                bindMaskSumTex(maskSum);
             }
         }
 
@@ -171,9 +176,7 @@ namespace
                 const int layer_rows = img_rows >> octave;
                 const int layer_cols = img_cols >> octave;
 
-                uploadConstant("cv::gpu::surf::c_octave",     octave);
-                uploadConstant("cv::gpu::surf::c_layer_rows", layer_rows);
-                uploadConstant("cv::gpu::surf::c_layer_cols", layer_cols);
+                loadOctaveConstants(octave, layer_rows, layer_cols);
 
                 icvCalcLayerDetAndTrace_gpu(det, trace, img_rows, img_cols, octave, nOctaveLayers);
 
@@ -242,8 +245,6 @@ namespace
         int maxFeatures;
 
         GpuMat counters;
-
-        TextureBinder imgTex, sumTex, maskSumTex;
     };
 }
 
@@ -336,7 +337,7 @@ void cv::gpu::SURF_GPU::downloadKeypoints(const GpuMat& keypointsGPU, vector<Key
     {
         CV_Assert(keypointsGPU.type() == CV_32FC1 && keypointsGPU.rows == SF_FEATURE_STRIDE);
         
-        Mat keypointsCPU = keypointsGPU;
+        Mat keypointsCPU(keypointsGPU);
         
         keypoints.resize(nFeatures);
 
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 7392daff04fcb28e3afab4c43f2aa5e83cfa5dee..e9b2ef8d2b4737c7491a12e9f6a6d5e984836ce3 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -549,8 +549,8 @@ TEST_P(MorphEx, Accuracy)
         cv::gpu::GpuMat dev_dst_rgba;
         cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::morphologyEx(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, morphOps[morphOpsIdx], cv::gpu::GpuMat(kernel));
-        cv::gpu::morphologyEx(cv::gpu::GpuMat(img_gray), dev_dst_gray, morphOps[morphOpsIdx], cv::gpu::GpuMat(kernel));
+        cv::gpu::morphologyEx(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, morphOps[morphOpsIdx], kernel);
+        cv::gpu::morphologyEx(cv::gpu::GpuMat(img_gray), dev_dst_gray, morphOps[morphOpsIdx], kernel);
 
         dev_dst_rgba.download(dst_rgba);
         dev_dst_gray.download(dst_gray);
diff --git a/modules/gpu/test/test_hog.cpp b/modules/gpu/test/test_hog.cpp
index 548e3e51c8def5a8df43a6532c50389631b3a541..c8afa058f1759b260800203735e58a5fd15afbdc 100644
--- a/modules/gpu/test/test_hog.cpp
+++ b/modules/gpu/test/test_hog.cpp
@@ -137,7 +137,7 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
 #ifdef DUMP
         dump(block_hists, locations);
 #else
-        compare(block_hists, locations);
+        compare(cv::Mat(block_hists), locations);
 #endif
 
         // Test detect on smaller image
@@ -148,7 +148,7 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
 #ifdef DUMP
         dump(block_hists, locations);
 #else
-        compare(block_hists, locations);
+        compare(cv::Mat(block_hists), locations);
 #endif
 
         // Test detect on greater image
@@ -158,7 +158,7 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
 #ifdef DUMP
         dump(block_hists, locations);
 #else
-        compare(block_hists, locations);
+        compare(cv::Mat(block_hists), locations);
 #endif
     }
 
@@ -254,31 +254,31 @@ struct CV_GpuHogGetDescriptorsTestRunner : cv::gpu::HOGDescriptor
         ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(block_hists, descriptors.rowRange(1, 2));
+        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(block_hists, descriptors.rowRange(2, 3));
+        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(block_hists, descriptors.rowRange(3, 4));
+        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(block_hists, descriptors.rowRange(4, 5));
+        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(block_hists, descriptors.rowRange(5, 6));
+        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
     }
 
     // Does not compare border value, as interpolation leads to delta
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index 3e8abf8659fc9273313c7f38856e5e0713cc349c..85c569317b4fa8ad58baa423f9314d44f3fe71ed 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -3897,7 +3897,7 @@ static void testC2C(const std::string& hint, int cols, int rows, int flags, bool
     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, d_b, rows * cols * 1e-4);
+    EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);
 }
 
 TEST_P(Dft, C2C)
diff --git a/samples/gpu/stereo_match.cpp b/samples/gpu/stereo_match.cpp
index 1dce494cdfac75581841a6527f5ab8adfa203ed1..39aef1ce958f76c355880c24e477fe561b0dab71 100644
--- a/samples/gpu/stereo_match.cpp
+++ b/samples/gpu/stereo_match.cpp
@@ -206,7 +206,7 @@ void App::run()
         workEnd();
 
         // Show results
-        disp = d_disp;
+        d_disp.download(disp);
         putText(disp, text(), Point(5, 25), FONT_HERSHEY_SIMPLEX, 1.0, Scalar::all(255));
         imshow("disparity", disp);
 
diff --git a/samples/gpu/surf_keypoint_matcher.cpp b/samples/gpu/surf_keypoint_matcher.cpp
index b020408f63b07677d249a42ddab807ed6608e65f..f87fe5fcb95518322bf698477638436478799440 100644
--- a/samples/gpu/surf_keypoint_matcher.cpp
+++ b/samples/gpu/surf_keypoint_matcher.cpp
@@ -1,29 +1,29 @@
-#include <iostream>
-
-#include "opencv2/core/core.hpp"
-#include "opencv2/features2d/features2d.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/gpu/gpu.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace cv::gpu;
-
-void help()
-{
-    cout << "\nThis program demonstrates using SURF_GPU features detector, descriptor extractor and BruteForceMatcher_GPU" << endl;
-    cout << "\nUsage:\n\tmatcher_simple_gpu --left <image1> --right <image2>" << endl;
-}
-
-int main(int argc, char* argv[])
-{
-    if (argc != 5)
-    {
-        help();
-        return -1;
-    }
-
-    GpuMat img1, img2;
+#include <iostream>
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/gpu/gpu.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+void help()
+{
+    cout << "\nThis program demonstrates using SURF_GPU features detector, descriptor extractor and BruteForceMatcher_GPU" << endl;
+    cout << "\nUsage:\n\tmatcher_simple_gpu --left <image1> --right <image2>" << endl;
+}
+
+int main(int argc, char* argv[])
+{
+    if (argc != 5)
+    {
+        help();
+        return -1;
+    }
+
+    GpuMat img1, img2;
     for (int i = 1; i < argc; ++i)
     {
         if (string(argv[i]) == "--left")
@@ -41,41 +41,41 @@ int main(int argc, char* argv[])
             help();
             return -1;
         }
-    }
-
-    SURF_GPU surf;
-
-    // detecting keypoints & computing descriptors
-    GpuMat keypoints1GPU, keypoints2GPU;
-    GpuMat descriptors1GPU, descriptors2GPU;
-    surf(img1, GpuMat(), keypoints1GPU, descriptors1GPU);
-    surf(img2, GpuMat(), keypoints2GPU, descriptors2GPU);
-    
-    cout << "FOUND " << keypoints1GPU.cols << " keypoints on first image" << endl;
-    cout << "FOUND " << keypoints2GPU.cols << " keypoints on second image" << endl;
-
-    // matching descriptors
-    BruteForceMatcher_GPU< L2<float> > matcher;
-    GpuMat trainIdx, distance;
-    matcher.matchSingle(descriptors1GPU, descriptors2GPU, trainIdx, distance);
-    
-    // downloading results
-    vector<KeyPoint> keypoints1, keypoints2;
-    vector<float> descriptors1, descriptors2;
-    vector<DMatch> matches;
-    surf.downloadKeypoints(keypoints1GPU, keypoints1);
-    surf.downloadKeypoints(keypoints2GPU, keypoints2);
-    surf.downloadDescriptors(descriptors1GPU, descriptors1);
-    surf.downloadDescriptors(descriptors2GPU, descriptors2);
-    BruteForceMatcher_GPU< L2<float> >::matchDownload(trainIdx, distance, matches);
-
-    // drawing the results
-    Mat img_matches;
-    drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches);
-    
-    namedWindow("matches", 0);
-    imshow("matches", img_matches);
-    waitKey(0);
-
-    return 0;
-}
+    }
+
+    SURF_GPU surf;
+
+    // detecting keypoints & computing descriptors
+    GpuMat keypoints1GPU, keypoints2GPU;
+    GpuMat descriptors1GPU, descriptors2GPU;
+    surf(img1, GpuMat(), keypoints1GPU, descriptors1GPU);
+    surf(img2, GpuMat(), keypoints2GPU, descriptors2GPU);
+    
+    cout << "FOUND " << keypoints1GPU.cols << " keypoints on first image" << endl;
+    cout << "FOUND " << keypoints2GPU.cols << " keypoints on second image" << endl;
+
+    // matching descriptors
+    BruteForceMatcher_GPU< L2<float> > matcher;
+    GpuMat trainIdx, distance;
+    matcher.matchSingle(descriptors1GPU, descriptors2GPU, trainIdx, distance);
+    
+    // downloading results
+    vector<KeyPoint> keypoints1, keypoints2;
+    vector<float> descriptors1, descriptors2;
+    vector<DMatch> matches;
+    surf.downloadKeypoints(keypoints1GPU, keypoints1);
+    surf.downloadKeypoints(keypoints2GPU, keypoints2);
+    surf.downloadDescriptors(descriptors1GPU, descriptors1);
+    surf.downloadDescriptors(descriptors2GPU, descriptors2);
+    BruteForceMatcher_GPU< L2<float> >::matchDownload(trainIdx, distance, matches);
+
+    // drawing the results
+    Mat img_matches;
+    drawMatches(Mat(img1), keypoints1, Mat(img2), keypoints2, matches, img_matches);
+    
+    namedWindow("matches", 0);
+    imshow("matches", img_matches);
+    waitKey(0);
+
+    return 0;
+}