Merge remote-tracking branch 'origin/2.4' into merge-2.4

[profile/ivi/opencv.git] / modules / ocl / src / arithm.cpp

diff --git a/modules/ocl/src/arithm.cpp b/modules/ocl/src/arithm.cpp
index 68c5269..0acb4c2 100644 (file)
--- a/modules/ocl/src/arithm.cpp
+++ b/modules/ocl/src/arithm.cpp
@@ -86,7 +86,7 @@ static void arithmetic_run_generic(const oclMat &src1, const oclMat &src2, const
     bool hasDouble = clCxt->supportsFeature(FEATURE_CL_DOUBLE);
     if (!hasDouble && (src1.depth() == CV_64F || src2.depth() == CV_64F || dst.depth() == CV_64F))
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -129,16 +129,16 @@ static void arithmetic_run_generic(const oclMat &src1, const oclMat &src2, const
                                       typeMap[depth], channelMap[oclChannels], (depth >= CV_32F ? "" : (depth == CV_32S ? "_rte" : "_sat_rte")),
                                       funcMap[op_type], WTypeMap[WDepth], channelMap[oclChannels]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1offset1 ));
 
     if (!src2.empty())
     {
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2step1 ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2offset1 ));
 
         kernelName += "_mat";
 
@@ -151,26 +151,26 @@ static void arithmetic_run_generic(const oclMat &src1, const oclMat &src2, const
         const int WDepthMap[] = { CV_16S, CV_16S, CV_32S, CV_32S, CV_32S, CV_32F, CV_64F };
         m = scalarToVector(scalar, WDepthMap[WDepth], oclChannels, src1.channels());
 
-        args.push_back( make_pair( m.size(), (void *)&m[0]));
+        args.push_back( std::make_pair( m.size(), (void *)&m[0]));
 
         kernelName += "_scalar";
     }
 
     if (!mask.empty())
     {
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&mask.data ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&maskstep1 ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&maskoffset1 ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&mask.data ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&maskstep1 ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&maskoffset1 ));
 
         kernelName += "_mask";
     }
 
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dststep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
 
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
 
     openCLExecuteKernel(clCxt, mask.empty() ?
                             (!src2.empty() ? &arithm_add : &arithm_add_scalar) :
@@ -256,7 +256,7 @@ void cv::ocl::absdiff(const oclMat &src1, const Scalar &src2, oclMat &dst)
 //////////////////////////////////////////////////////////////////////////////
 
 static void compare_run(const oclMat &src1, const oclMat &src2, oclMat &dst, int cmpOp,
-                        string kernelName, const cv::ocl::ProgramEntry* source)
+                        String kernelName, const cv::ocl::ProgramEntry* source)
 {
     dst.create(src1.size(), CV_8UC1);
 
@@ -272,18 +272,18 @@ static void compare_run(const oclMat &src1, const oclMat &src2, oclMat &dst, int
     const char * operationMap[] = { "==", ">", ">=", "<", "<=", "!=" };
     std::string buildOptions = format("-D T=%s -D Operation=%s", typeMap[depth], operationMap[cmpOp]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dststep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
 
     openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads,
                         args, -1, -1, buildOptions.c_str());
@@ -293,7 +293,7 @@ void cv::ocl::compare(const oclMat &src1, const oclMat &src2, oclMat &dst , int
 {
     if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -322,20 +322,20 @@ static void arithmetic_sum_buffer_run(const oclMat &src, cl_mem &dst, int groupn
     const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
     const char * const funcMap[] = { "FUNC_SUM", "FUNC_ABS_SUM", "FUNC_SQR_SUM" };
     const char * const channelMap[] = { " ", " ", "2", "4", "4" };
-    string buildOptions = format("-D srcT=%s%s -D dstT=%s%s -D convertToDstT=convert_%s%s -D %s",
+    String buildOptions = format("-D srcT=%s%s -D dstT=%s%s -D convertToDstT=convert_%s%s -D %s",
                                  typeMap[src.depth()], channelMap[ochannels],
                                  typeMap[ddepth], channelMap[ochannels],
                                  typeMap[ddepth], channelMap[ochannels],
                                  funcMap[type]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&elemnum));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&groupnum));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&src.data));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst ));
     size_t globalThreads[3] = { groupnum * 256, 1, 1 };
     size_t localThreads[3] = { 256, 1, 1 };
 
@@ -377,7 +377,7 @@ Scalar cv::ocl::sum(const oclMat &src)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return Scalar::all(0);
     }
     static sumFunc functab[3] =
@@ -396,7 +396,7 @@ Scalar cv::ocl::absSum(const oclMat &src)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return cv::Scalar::all(0);
     }
 
@@ -416,7 +416,7 @@ Scalar cv::ocl::sqrSum(const oclMat &src)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return cv::Scalar::all(0);
     }
     static sumFunc functab[3] =
@@ -439,7 +439,7 @@ void cv::ocl::meanStdDev(const oclMat &src, Scalar &mean, Scalar &stddev)
 {
     if (src.depth() == CV_64F && !src.clCxt->supportsFeature(FEATURE_CL_DOUBLE))
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -460,7 +460,7 @@ void cv::ocl::meanStdDev(const oclMat &src, Scalar &mean, Scalar &stddev)
 //////////////////////////////////////////////////////////////////////////////
 
 template <typename T, typename WT>
-static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem &dst, int groupnum, string kernelName)
+static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem &dst, int groupnum, String kernelName)
 {
     int all_cols = src.step / src.elemSize();
     int pre_cols = (src.offset % src.step) / src.elemSize();
@@ -472,25 +472,25 @@ static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem
     const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
     const char * const channelMap[] = { " ", " ", "2", "4", "4" };
 
-    ostringstream stream;
+    std::ostringstream stream;
     stream << "-D T=" << typeMap[src.depth()] << channelMap[src.channels()];
-    if (numeric_limits<T>::is_integer)
+    if (std::numeric_limits<T>::is_integer)
     {
-        stream << " -D MAX_VAL=" << (WT)numeric_limits<T>::max();
-        stream << " -D MIN_VAL=" << (WT)numeric_limits<T>::min();
+        stream << " -D MAX_VAL=" << (WT)std::numeric_limits<T>::max();
+        stream << " -D MIN_VAL=" << (WT)std::numeric_limits<T>::min();
     }
     else
         stream << " -D DEPTH_" << src.depth();
     std::string buildOptions = stream.str();
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&src.data));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&elemnum));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&groupnum));
 
     int minvalid_cols = 0, moffset = 0;
     if (!mask.empty())
@@ -501,11 +501,11 @@ static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem
         minvalid_cols = mpre_cols + msec_cols;
         moffset = mask.offset / mask.elemSize();
 
-        args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data ));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&minvalid_cols ));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&moffset ));
+        args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&mask.data ));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&minvalid_cols ));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&moffset ));
 
-        kernelName += "_mask";
+        kernelName = kernelName + "_mask";
     }
 
     size_t globalThreads[3] = {groupnum * 256, 1, 1};
@@ -557,7 +557,7 @@ void cv::ocl::minMax(const oclMat &src, double *minVal, double *maxVal, const oc
 
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -594,7 +594,7 @@ static void arithm_absdiff_nonsaturate_run(const oclMat & src1, const oclMat & s
     Context *clCxt = src1.clCxt;
     if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
     CV_Assert(src1.step % src1.elemSize() == 0 && (src2.empty() || src2.step % src2.elemSize() == 0));
@@ -611,7 +611,7 @@ static void arithm_absdiff_nonsaturate_run(const oclMat & src1, const oclMat & s
     int src2step1 = src2.step / src2.elemSize(), src2offset1 = src2.offset / src2.elemSize();
     int diffstep1 = diff.step / diff.elemSize(), diffoffset1 = diff.offset / diff.elemSize();
 
-    string kernelName = "arithm_absdiff_nonsaturate";
+    String kernelName = "arithm_absdiff_nonsaturate";
     size_t localThreads[3]  = { 16, 16, 1 };
     size_t globalThreads[3] = { diff.cols, diff.rows, 1 };
 
@@ -623,26 +623,26 @@ static void arithm_absdiff_nonsaturate_run(const oclMat & src1, const oclMat & s
                                       typeMap[ddepth], channelMap[oclChannels],
                                       typeMap[ddepth], channelMap[oclChannels]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1offset1 ));
 
     if (!src2.empty())
     {
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2step1 ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2offset1 ));
 
-        kernelName += "_binary";
+        kernelName = kernelName + "_binary";
     }
 
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&diff.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&diffstep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&diffoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&diff.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&diffstep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&diffoffset1 ));
 
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
 
     openCLExecuteKernel(clCxt, &arithm_absdiff_nonsaturate,
                         kernelName, globalThreads, localThreads,
@@ -653,7 +653,7 @@ double cv::ocl::norm(const oclMat &src1, const oclMat &src2, int normType)
 {
     if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return -1;
     }
     CV_Assert(src2.empty() || (src1.type() == src2.type() && src1.size() == src2.size()));
@@ -699,7 +699,7 @@ double cv::ocl::norm(const oclMat &src1, const oclMat &src2, int normType)
 
 enum { FLIP_COLS = 1 << 0, FLIP_ROWS = 1 << 1, FLIP_BOTH = FLIP_ROWS | FLIP_COLS };
 
-static void arithmetic_flip_run(const oclMat &src, oclMat &dst, string kernelName, int flipType)
+static void arithmetic_flip_run(const oclMat &src, oclMat &dst, String kernelName, int flipType)
 {
     int cols = dst.cols, rows = dst.rows;
     if ((cols == 1 && flipType == FLIP_COLS) ||
@@ -724,17 +724,17 @@ static void arithmetic_flip_run(const oclMat &src, oclMat &dst, string kernelNam
     int src_step = src.step / elemSize, src_offset = src.offset / elemSize;
     int dst_step = dst.step / elemSize, dst_offset = dst.offset / elemSize;
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_offset ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols ));
 
     openCLExecuteKernel(src.clCxt, &arithm_flip, kernelName, globalThreads, localThreads, args,
                         -1, -1, buildOptions.c_str());
@@ -744,7 +744,7 @@ void cv::ocl::flip(const oclMat &src, oclMat &dst, int flipCode)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -762,7 +762,7 @@ void cv::ocl::flip(const oclMat &src, oclMat &dst, int flipCode)
 ////////////////////////////////// LUT  //////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static void arithmetic_lut_run(const oclMat &src, const oclMat &lut, oclMat &dst, string kernelName)
+static void arithmetic_lut_run(const oclMat &src, const oclMat &lut, oclMat &dst, String kernelName)
 {
     int sdepth = src.depth();
     int src_step1 = src.step1(), dst_step1 = dst.step1();
@@ -776,17 +776,17 @@ static void arithmetic_lut_run(const oclMat &src, const oclMat &lut, oclMat &dst
     const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
     std::string buildOptions = format("-D srcT=%s -D dstT=%s", typeMap[sdepth], typeMap[dst.depth()]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&lut.data ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols1));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&lut_offset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src.data ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&lut.data ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols1));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&lut_offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_step1 ));
 
     openCLExecuteKernel(src.clCxt, &arithm_LUT, kernelName, globalSize, localSize,
                         args, lut.oclchannels(), -1, buildOptions.c_str());
@@ -796,7 +796,7 @@ void cv::ocl::LUT(const oclMat &src, const oclMat &lut, oclMat &dst)
 {
     if (!lut.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && lut.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -814,12 +814,12 @@ void cv::ocl::LUT(const oclMat &src, const oclMat &lut, oclMat &dst)
 //////////////////////////////// exp log /////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static void arithmetic_exp_log_run(const oclMat &src, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
+static void arithmetic_exp_log_run(const oclMat &src, oclMat &dst, String kernelName, const cv::ocl::ProgramEntry* source)
 {
     Context  *clCxt = src.clCxt;
     if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -837,15 +837,15 @@ static void arithmetic_exp_log_run(const oclMat &src, oclMat &dst, string kernel
     std::string buildOptions = format("-D srcT=%s",
                                       ddepth == CV_32F ? "float" : "double");
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&srcoffset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&srcstep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src.data ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&srcoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&srcstep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dststep1 ));
 
     openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads,
                         args, src.oclchannels(), -1, buildOptions.c_str());
@@ -865,7 +865,7 @@ void cv::ocl::log(const oclMat &src, oclMat &dst)
 ////////////////////////////// magnitude phase ///////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static void arithmetic_magnitude_phase_run(const oclMat &src1, const oclMat &src2, oclMat &dst, string kernelName)
+static void arithmetic_magnitude_phase_run(const oclMat &src1, const oclMat &src2, oclMat &dst, String kernelName)
 {
     int depth = dst.depth();
 
@@ -876,18 +876,18 @@ static void arithmetic_magnitude_phase_run(const oclMat &src1, const oclMat &src
     int src2_step = src2.step / src2.elemSize(), src2_offset = src2.offset / src2.elemSize();
     int dst_step = dst.step / dst.elemSize(), dst_offset = dst.offset / dst.elemSize();
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.cols ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_offset ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.cols ));
 
     const char * const channelMap[] = { "", "", "2", "4", "4" };
     std::string buildOptions = format("-D T=%s%s", depth == CV_32F ? "float" : "double", channelMap[dst.channels()]);
@@ -899,7 +899,7 @@ void cv::ocl::magnitude(const oclMat &src1, const oclMat &src2, oclMat &dst)
 {
     if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -910,7 +910,7 @@ void cv::ocl::magnitude(const oclMat &src1, const oclMat &src2, oclMat &dst)
     arithmetic_magnitude_phase_run(src1, src2, dst, "arithm_magnitude");
 }
 
-static void arithmetic_phase_run(const oclMat &src1, const oclMat &src2, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
+static void arithmetic_phase_run(const oclMat &src1, const oclMat &src2, oclMat &dst, String kernelName, const cv::ocl::ProgramEntry* source)
 {
     int depth = dst.depth(), cols1 = src1.cols * src1.oclchannels();
     int src1step1 = src1.step / src1.elemSize1(), src1offset1 = src1.offset / src1.elemSize1();
@@ -920,18 +920,18 @@ static void arithmetic_phase_run(const oclMat &src1, const oclMat &src2, oclMat
     size_t localThreads[3]  = { 64, 4, 1 };
     size_t globalThreads[3] = { cols1, dst.rows, 1 };
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dststep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.rows ));
 
     openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
 }
@@ -940,7 +940,7 @@ void cv::ocl::phase(const oclMat &x, const oclMat &y, oclMat &Angle, bool angleI
 {
     if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -956,7 +956,7 @@ void cv::ocl::phase(const oclMat &x, const oclMat &y, oclMat &Angle, bool angleI
 //////////////////////////////////////////////////////////////////////////////
 
 static void arithmetic_cartToPolar_run(const oclMat &src1, const oclMat &src2, oclMat &dst_mag, oclMat &dst_cart,
-                                string kernelName, bool angleInDegrees)
+                                String kernelName, bool angleInDegrees)
 {
     int channels = src1.oclchannels();
     int depth = src1.depth();
@@ -971,21 +971,21 @@ static void arithmetic_cartToPolar_run(const oclMat &src1, const oclMat &src2, o
     int dst_mag_step = dst_mag.step / dst_mag.elemSize1(), dst_mag_offset = dst_mag.offset / dst_mag.elemSize1();
     int dst_cart_step = dst_cart.step / dst_cart.elemSize1(), dst_cart_offset = dst_cart.offset / dst_cart.elemSize1();
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst_mag.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_mag_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_mag_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst_cart.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_cart_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_cart_offset ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst_mag.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_mag_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_mag_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst_cart.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_cart_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_cart_offset ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols ));
 
     openCLExecuteKernel(src1.clCxt, &arithm_cartToPolar, kernelName, globalThreads, localThreads, args,
                         -1, depth, angleInDegrees ? "-D DEGREE" : "-D RADIAN");
@@ -995,7 +995,7 @@ void cv::ocl::cartToPolar(const oclMat &x, const oclMat &y, oclMat &mag, oclMat
 {
     if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1012,7 +1012,7 @@ void cv::ocl::cartToPolar(const oclMat &x, const oclMat &y, oclMat &mag, oclMat
 //////////////////////////////////////////////////////////////////////////////
 
 static void arithmetic_ptc_run(const oclMat &src1, const oclMat &src2, oclMat &dst1, oclMat &dst2, bool angleInDegrees,
-                        string kernelName)
+                        String kernelName)
 {
     int channels = src2.oclchannels(), depth = src2.depth();
     int cols = src2.cols * channels, rows = src2.rows;
@@ -1025,24 +1025,24 @@ static void arithmetic_ptc_run(const oclMat &src1, const oclMat &src2, oclMat &d
     int dst1_step = dst1.step / dst1.elemSize1(), dst1_offset = dst1.offset / dst1.elemSize1();
     int dst2_step = dst2.step / dst2.elemSize1(), dst2_offset = dst2.offset / dst2.elemSize1();
 
-    vector<pair<size_t , const void *> > args;
+    std::vector<std::pair<size_t , const void *> > args;
     if (src1.data)
     {
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src1_step ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src1_offset ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1_step ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1_offset ));
     }
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst1_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst1_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst2_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst2_offset ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst1_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst1_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst2_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst2_offset ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols ));
 
     openCLExecuteKernel(src1.clCxt, &arithm_polarToCart, kernelName, globalThreads, localThreads,
                         args, -1, depth, angleInDegrees ? "-D DEGREE" : "-D RADIAN");
@@ -1052,7 +1052,7 @@ void cv::ocl::polarToCart(const oclMat &magnitude, const oclMat &angle, oclMat &
 {
     if (!magnitude.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && magnitude.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1074,7 +1074,7 @@ void cv::ocl::polarToCart(const oclMat &magnitude, const oclMat &angle, oclMat &
 
 static void arithmetic_minMaxLoc_run(const oclMat &src, cl_mem &dst, int vlen , int groupnum)
 {
-    vector<pair<size_t , const void *> > args;
+    std::vector<std::pair<size_t , const void *> > args;
     int all_cols = src.step / (vlen * src.elemSize1());
     int pre_cols = (src.offset % src.step) / (vlen * src.elemSize1());
     int sec_cols = all_cols - (src.offset % src.step + src.cols * src.elemSize1() - 1) / (vlen * src.elemSize1()) - 1;
@@ -1083,13 +1083,13 @@ static void arithmetic_minMaxLoc_run(const oclMat &src, cl_mem &dst, int vlen ,
     int offset = src.offset / (vlen * src.elemSize1());
     int repeat_s = src.offset / src.elemSize1() - offset * vlen;
     int repeat_e = (offset + cols) * vlen - src.offset / src.elemSize1() - src.cols;
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&elemnum));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&groupnum));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&src.data));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst ));
     char build_options[50];
     sprintf(build_options, "-D DEPTH_%d -D REPEAT_S%d -D REPEAT_E%d", src.depth(), repeat_s, repeat_e);
     size_t gt[3] = {groupnum * 256, 1, 1}, lt[3] = {256, 1, 1};
@@ -1098,7 +1098,7 @@ static void arithmetic_minMaxLoc_run(const oclMat &src, cl_mem &dst, int vlen ,
 
 static void arithmetic_minMaxLoc_mask_run(const oclMat &src, const oclMat &mask, cl_mem &dst, int vlen, int groupnum)
 {
-    vector<pair<size_t , const void *> > args;
+    std::vector<std::pair<size_t , const void *> > args;
     size_t gt[3] = {groupnum * 256, 1, 1}, lt[3] = {256, 1, 1};
     char build_options[50];
     if (src.oclchannels() == 1)
@@ -1111,16 +1111,16 @@ static void arithmetic_minMaxLoc_mask_run(const oclMat &src, const oclMat &mask,
         int moffset = mask.offset / mask.elemSize1();
         int elemnum = cols * src.rows;
         sprintf(build_options, "-D DEPTH_%d -D REPEAT_E%d", src.depth(), repeat_me);
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
-        args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&minvalid_cols ));
-        args.push_back( make_pair( sizeof(cl_int) , (void *)&moffset ));
-        args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data ));
-        args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&cols ));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&elemnum));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&groupnum));
+        args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&src.data));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&minvalid_cols ));
+        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&moffset ));
+        args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&mask.data ));
+        args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst ));
 
         openCLExecuteKernel(src.clCxt, &arithm_minMaxLoc_mask, "arithm_op_minMaxLoc_mask", gt, lt, args, -1, -1, build_options);
     }
@@ -1195,7 +1195,7 @@ void cv::ocl::minMaxLoc(const oclMat &src, double *minVal, double *maxVal,
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1214,7 +1214,7 @@ void cv::ocl::minMaxLoc(const oclMat &src, double *minVal, double *maxVal,
 ///////////////////////////// countNonZero ///////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static void arithmetic_countNonZero_run(const oclMat &src, cl_mem &dst, int groupnum, string kernelName)
+static void arithmetic_countNonZero_run(const oclMat &src, cl_mem &dst, int groupnum, String kernelName)
 {
     int ochannels = src.oclchannels();
     int all_cols = src.step / src.elemSize();
@@ -1226,17 +1226,17 @@ static void arithmetic_countNonZero_run(const oclMat &src, cl_mem &dst, int grou
 
     const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
     const char * const channelMap[] = { " ", " ", "2", "4", "4" };
-    string buildOptions = format("-D srcT=%s%s -D dstT=int%s", typeMap[src.depth()], channelMap[ochannels],
+    String buildOptions = format("-D srcT=%s%s -D dstT=int%s", typeMap[src.depth()], channelMap[ochannels],
                                  channelMap[ochannels]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
-    args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
-    args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&elemnum));
+    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&groupnum));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&src.data));
+    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst ));
 
     size_t globalThreads[3] = { groupnum * 256, 1, 1 };
     size_t localThreads[3] = { 256, 1, 1 };
@@ -1253,7 +1253,7 @@ int cv::ocl::countNonZero(const oclMat &src)
     Context *clCxt = src.clCxt;
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "selected device doesn't support double");
         return -1;
     }
 
@@ -1261,7 +1261,7 @@ int cv::ocl::countNonZero(const oclMat &src)
     CV_Assert(groupnum != 0);
     int dbsize = groupnum;
 
-    string kernelName = "arithm_op_nonzero";
+    String kernelName = "arithm_op_nonzero";
 
     AutoBuffer<int> _buf(dbsize);
     int *p = (int*)_buf, nonzero = 0;
@@ -1283,7 +1283,7 @@ int cv::ocl::countNonZero(const oclMat &src)
 ////////////////////////////////bitwise_op////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static void bitwise_unary_run(const oclMat &src1, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
+static void bitwise_unary_run(const oclMat &src1, oclMat &dst, String kernelName, const cv::ocl::ProgramEntry* source)
 {
     dst.create(src1.size(), src1.type());
 
@@ -1304,16 +1304,16 @@ static void bitwise_unary_run(const oclMat &src1, oclMat &dst, string kernelName
     size_t globalThreads[3] = { cols, dst.rows, 1 };
 
     int dst_step1 = dst.cols * dst.elemSize();
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.offset ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_step1 ));
 
     openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
 }
@@ -1343,42 +1343,42 @@ static void bitwise_binary_run(const oclMat &src1, const oclMat &src2, const Sca
     size_t localThreads[3]  = { 16, 16, 1 };
     size_t globalThreads[3] = { dst.cols, dst.rows, 1 };
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.offset ));
 
     if (src2.empty())
     {
         m.create(1, 1, dst.type());
         m.setTo(src3);
 
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&m.data ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&m.data ));
 
         kernelName += "_scalar";
     }
     else
     {
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src2.step ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&src2.offset ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2.step ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2.offset ));
     }
 
     if (!mask.empty())
     {
-        args.push_back( make_pair( sizeof(cl_mem), (void *)&mask.data ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&mask.step ));
-        args.push_back( make_pair( sizeof(cl_int), (void *)&mask.offset ));
+        args.push_back( std::make_pair( sizeof(cl_mem), (void *)&mask.data ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&mask.step ));
+        args.push_back( std::make_pair( sizeof(cl_int), (void *)&mask.offset ));
 
         kernelName += "_mask";
     }
 
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.offset ));
 
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
 
     openCLExecuteKernel(src1.clCxt, mask.empty() ? (!src2.empty() ? &arithm_bitwise_binary : &arithm_bitwise_binary_scalar) :
                                               (!src2.empty() ? &arithm_bitwise_binary_mask : &arithm_bitwise_binary_scalar_mask),
@@ -1390,7 +1390,7 @@ void cv::ocl::bitwise_not(const oclMat &src, oclMat &dst)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1513,7 +1513,7 @@ oclMatExpr::operator oclMat() const
 #define TILE_DIM   (32)
 #define BLOCK_ROWS (256 / TILE_DIM)
 
-static void transpose_run(const oclMat &src, oclMat &dst, string kernelName, bool inplace = false)
+static void transpose_run(const oclMat &src, oclMat &dst, String kernelName, bool inplace = false)
 {
     const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
     const char channelsString[] = { ' ', ' ', '2', '4', '4' };
@@ -1526,15 +1526,15 @@ static void transpose_run(const oclMat &src, oclMat &dst, string kernelName, boo
     int srcstep1 = src.step / src.elemSize(), dststep1 = dst.step / dst.elemSize();
     int srcoffset1 = src.offset / src.elemSize(), dstoffset1 = dst.offset / dst.elemSize();
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src.cols ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&srcstep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&srcoffset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src.data ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src.cols ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&srcstep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dststep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&srcoffset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
 
     openCLExecuteKernel(src.clCxt, &arithm_transpose, kernelName, globalThreads, localThreads,
                         args, -1, -1, buildOptions.c_str());
@@ -1544,7 +1544,7 @@ void cv::ocl::transpose(const oclMat &src, oclMat &dst)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1568,7 +1568,7 @@ void cv::ocl::addWeighted(const oclMat &src1, double alpha, const oclMat &src2,
     bool hasDouble = clCxt->supportsFeature(FEATURE_CL_DOUBLE);
     if (!hasDouble && src1.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1595,32 +1595,32 @@ void cv::ocl::addWeighted(const oclMat &src1, double alpha, const oclMat &src2,
             beta_f = static_cast<float>(beta),
             gama_f = static_cast<float>(gama);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src1.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1offset1));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src2.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2offset1));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dststep1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dstoffset1));
 
     if (!hasDouble)
     {
-        args.push_back( make_pair( sizeof(cl_float), (void *)&alpha_f ));
-        args.push_back( make_pair( sizeof(cl_float), (void *)&beta_f ));
-        args.push_back( make_pair( sizeof(cl_float), (void *)&gama_f ));
+        args.push_back( std::make_pair( sizeof(cl_float), (void *)&alpha_f ));
+        args.push_back( std::make_pair( sizeof(cl_float), (void *)&beta_f ));
+        args.push_back( std::make_pair( sizeof(cl_float), (void *)&gama_f ));
     }
     else
     {
-        args.push_back( make_pair( sizeof(cl_double), (void *)&alpha ));
-        args.push_back( make_pair( sizeof(cl_double), (void *)&beta ));
-        args.push_back( make_pair( sizeof(cl_double), (void *)&gama ));
+        args.push_back( std::make_pair( sizeof(cl_double), (void *)&alpha ));
+        args.push_back( std::make_pair( sizeof(cl_double), (void *)&beta ));
+        args.push_back( std::make_pair( sizeof(cl_double), (void *)&gama ));
     }
 
-    args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&cols1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src1.rows ));
 
     openCLExecuteKernel(clCxt, &arithm_addWeighted, "addWeighted", globalThreads, localThreads,
                         args, -1, -1, buildOptions.c_str());
@@ -1630,7 +1630,7 @@ void cv::ocl::addWeighted(const oclMat &src1, double alpha, const oclMat &src2,
 /////////////////////////////////// Pow //////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static void arithmetic_pow_run(const oclMat &src, double p, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
+static void arithmetic_pow_run(const oclMat &src, double p, oclMat &dst, String kernelName, const cv::ocl::ProgramEntry* source)
 {
     int channels = dst.oclchannels();
     int depth = dst.depth();
@@ -1645,21 +1645,21 @@ static void arithmetic_pow_run(const oclMat &src, double p, oclMat &dst, string
     int src_step = src.step / src.elemSize(), src_offset = src.offset / src.elemSize();
     int dst_step = dst.step / dst.elemSize(), dst_offset = dst.offset / dst.elemSize();
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset ));
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&dst.cols ));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_offset ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&dst.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_step ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst_offset ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.rows ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&dst.cols ));
 
     float pf = static_cast<float>(p);
     if(src.depth() == CV_32F)
-        args.push_back( make_pair( sizeof(cl_float), (void *)&pf ));
+        args.push_back( std::make_pair( sizeof(cl_float), (void *)&pf ));
     else
-        args.push_back( make_pair( sizeof(cl_double), (void *)&p ));
+        args.push_back( std::make_pair( sizeof(cl_double), (void *)&p ));
 
     openCLExecuteKernel(src.clCxt, source, kernelName, globalThreads, localThreads, args, -1, -1, buildOptions.c_str());
 }
@@ -1668,7 +1668,7 @@ void cv::ocl::pow(const oclMat &x, double p, oclMat &y)
 {
     if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1686,7 +1686,7 @@ void cv::ocl::setIdentity(oclMat& src, const Scalar & scalar)
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
     {
-        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        CV_Error(Error::OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 
@@ -1698,17 +1698,17 @@ void cv::ocl::setIdentity(oclMat& src, const Scalar & scalar)
 
     const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
     const char * const channelMap[] = { "", "", "2", "4", "4" };
-    string buildOptions = format("-D T=%s%s", typeMap[src.depth()], channelMap[src.oclchannels()]);
+    String buildOptions = format("-D T=%s%s", typeMap[src.depth()], channelMap[src.oclchannels()]);
 
-    vector<pair<size_t , const void *> > args;
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_step1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset1 ));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src.cols));
-    args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows));
+    std::vector<std::pair<size_t , const void *> > args;
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&src.data ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_step1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src_offset1 ));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src.cols));
+    args.push_back( std::make_pair( sizeof(cl_int), (void *)&src.rows));
 
     oclMat sc(1, 1, src.type(), scalar);
-    args.push_back( make_pair( sizeof(cl_mem), (void *)&sc.data ));
+    args.push_back( std::make_pair( sizeof(cl_mem), (void *)&sc.data ));
 
     openCLExecuteKernel(src.clCxt, &arithm_setidentity, "setIdentity", global_threads, local_threads,
                         args, -1, -1, buildOptions.c_str());