fixed pyrlk optical flow

diff --git a/modules/ocl/src/pyrlk.cpp b/modules/ocl/src/pyrlk.cpp
index eae5f85..7b77af2 100644 (file)
--- a/modules/ocl/src/pyrlk.cpp
+++ b/modules/ocl/src/pyrlk.cpp
@@ -45,23 +45,21 @@
 //
 //M*/
 
-
 #include "precomp.hpp"
+
 using namespace cv;
 using namespace cv::ocl;
 
 namespace cv
 {
-namespace ocl
-{
-extern const char *pyrlk;
-extern const char *pyrlk_no_image;
-extern const char *operator_setTo;
-extern const char *operator_convertTo;
-extern const char *operator_copyToM;
-extern const char *pyr_down;
-}
+    namespace ocl
+    {
+        extern const char *pyrlk;
+        extern const char *pyrlk_no_image;
+        extern const char *pyr_down;
+    }
 }
+
 struct dim3
 {
     unsigned int x, y, z;
@@ -88,345 +86,6 @@ static void calcPatchSize(cv::Size winSize, int cn, dim3 &block, dim3 &patch, bo
     block.z = patch.z = 1;
 }
 
-///////////////////////////////////////////////////////////////////////////
-//////////////////////////////// ConvertTo ////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-static void convert_run_cus(const oclMat &src, oclMat &dst, double alpha, double beta)
-{
-    String kernelName = "convert_to_S";
-    std::stringstream idxStr;
-    idxStr << src.depth();
-    kernelName = kernelName + idxStr.str().c_str();
-    float alpha_f = (float)alpha, beta_f = (float)beta;
-    CV_DbgAssert(src.rows == dst.rows && src.cols == dst.cols);
-    std::vector<std::pair<size_t , const void *> > args;
-    size_t localThreads[3] = {16, 16, 1};
-    size_t globalThreads[3];
-    globalThreads[0] = (dst.cols + localThreads[0] - 1) / localThreads[0] * localThreads[0];
-    globalThreads[1] = (dst.rows + localThreads[1] - 1) / localThreads[1] * localThreads[1];
-    globalThreads[2] = 1;
-    int dststep_in_pixel = dst.step / dst.elemSize(), dstoffset_in_pixel = dst.offset / dst.elemSize();
-    int srcstep_in_pixel = src.step / src.elemSize(), srcoffset_in_pixel = src.offset / src.elemSize();
-    if(dst.type() == CV_8UC1)
-    {
-        globalThreads[0] = ((dst.cols + 4) / 4 + localThreads[0]) / localThreads[0] * localThreads[0];
-    }
-    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 *)&srcstep_in_pixel ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&srcoffset_in_pixel ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dststep_in_pixel ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dstoffset_in_pixel ));
-    args.push_back( std::make_pair( sizeof(cl_float) , (void *)&alpha_f ));
-    args.push_back( std::make_pair( sizeof(cl_float) , (void *)&beta_f ));
-    openCLExecuteKernel2(dst.clCxt , &operator_convertTo, kernelName, globalThreads,
-                         localThreads, args, dst.oclchannels(), dst.depth(), CLFLUSH);
-}
-void convertTo( const oclMat &src, oclMat &m, int rtype, double alpha = 1, double beta = 0 );
-void convertTo( const oclMat &src, oclMat &dst, int rtype, double alpha, double beta )
-{
-    //cout << "cv::ocl::oclMat::convertTo()" << endl;
-
-    bool noScale = fabs(alpha - 1) < std::numeric_limits<double>::epsilon()
-                   && fabs(beta) < std::numeric_limits<double>::epsilon();
-
-    if( rtype < 0 )
-        rtype = src.type();
-    else
-        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), src.oclchannels());
-
-    int sdepth = src.depth(), ddepth = CV_MAT_DEPTH(rtype);
-    if( sdepth == ddepth && noScale )
-    {
-        src.copyTo(dst);
-        return;
-    }
-
-    oclMat temp;
-    const oclMat *psrc = &src;
-    if( sdepth != ddepth && psrc == &dst )
-        psrc = &(temp = src);
-
-    dst.create( src.size(), rtype );
-    convert_run_cus(*psrc, dst, alpha, beta);
-}
-
-///////////////////////////////////////////////////////////////////////////
-//////////////////////////////// setTo ////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-//oclMat &operator = (const Scalar &s)
-//{
-//    //cout << "cv::ocl::oclMat::=" << endl;
-//    setTo(s);
-//    return *this;
-//}
-static void set_to_withoutmask_run_cus(const oclMat &dst, const Scalar &scalar, String kernelName)
-{
-    std::vector<std::pair<size_t , const void *> > args;
-
-    size_t localThreads[3] = {16, 16, 1};
-    size_t globalThreads[3];
-    globalThreads[0] = (dst.cols + localThreads[0] - 1) / localThreads[0] * localThreads[0];
-    globalThreads[1] = (dst.rows + localThreads[1] - 1) / localThreads[1] * localThreads[1];
-    globalThreads[2] = 1;
-    int step_in_pixel = dst.step / dst.elemSize(), offset_in_pixel = dst.offset / dst.elemSize();
-    if(dst.type() == CV_8UC1)
-    {
-        globalThreads[0] = ((dst.cols + 4) / 4 + localThreads[0] - 1) / localThreads[0] * localThreads[0];
-    }
-    char compile_option[32];
-    union sc
-    {
-        cl_uchar4 uval;
-        cl_char4  cval;
-        cl_ushort4 usval;
-        cl_short4 shval;
-        cl_int4 ival;
-        cl_float4 fval;
-        cl_double4 dval;
-    } val;
-    switch(dst.depth())
-    {
-    case 0:
-        val.uval.s[0] = saturate_cast<uchar>(scalar.val[0]);
-        val.uval.s[1] = saturate_cast<uchar>(scalar.val[1]);
-        val.uval.s[2] = saturate_cast<uchar>(scalar.val[2]);
-        val.uval.s[3] = saturate_cast<uchar>(scalar.val[3]);
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=uchar");
-            args.push_back( std::make_pair( sizeof(cl_uchar) , (void *)&val.uval.s[0] ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=uchar4");
-            args.push_back( std::make_pair( sizeof(cl_uchar4) , (void *)&val.uval ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    case 1:
-        val.cval.s[0] = saturate_cast<char>(scalar.val[0]);
-        val.cval.s[1] = saturate_cast<char>(scalar.val[1]);
-        val.cval.s[2] = saturate_cast<char>(scalar.val[2]);
-        val.cval.s[3] = saturate_cast<char>(scalar.val[3]);
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=char");
-            args.push_back( std::make_pair( sizeof(cl_char) , (void *)&val.cval.s[0] ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=char4");
-            args.push_back( std::make_pair( sizeof(cl_char4) , (void *)&val.cval ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    case 2:
-        val.usval.s[0] = saturate_cast<ushort>(scalar.val[0]);
-        val.usval.s[1] = saturate_cast<ushort>(scalar.val[1]);
-        val.usval.s[2] = saturate_cast<ushort>(scalar.val[2]);
-        val.usval.s[3] = saturate_cast<ushort>(scalar.val[3]);
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=ushort");
-            args.push_back( std::make_pair( sizeof(cl_ushort) , (void *)&val.usval.s[0] ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=ushort4");
-            args.push_back( std::make_pair( sizeof(cl_ushort4) , (void *)&val.usval ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    case 3:
-        val.shval.s[0] = saturate_cast<short>(scalar.val[0]);
-        val.shval.s[1] = saturate_cast<short>(scalar.val[1]);
-        val.shval.s[2] = saturate_cast<short>(scalar.val[2]);
-        val.shval.s[3] = saturate_cast<short>(scalar.val[3]);
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=short");
-            args.push_back( std::make_pair( sizeof(cl_short) , (void *)&val.shval.s[0] ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=short4");
-            args.push_back( std::make_pair( sizeof(cl_short4) , (void *)&val.shval ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    case 4:
-        val.ival.s[0] = saturate_cast<int>(scalar.val[0]);
-        val.ival.s[1] = saturate_cast<int>(scalar.val[1]);
-        val.ival.s[2] = saturate_cast<int>(scalar.val[2]);
-        val.ival.s[3] = saturate_cast<int>(scalar.val[3]);
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=int");
-            args.push_back( std::make_pair( sizeof(cl_int) , (void *)&val.ival.s[0] ));
-            break;
-        case 2:
-            sprintf(compile_option, "-D GENTYPE=int2");
-            cl_int2 i2val;
-            i2val.s[0] = val.ival.s[0];
-            i2val.s[1] = val.ival.s[1];
-            args.push_back( std::make_pair( sizeof(cl_int2) , (void *)&i2val ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=int4");
-            args.push_back( std::make_pair( sizeof(cl_int4) , (void *)&val.ival ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    case 5:
-        val.fval.s[0] = (float)scalar.val[0];
-        val.fval.s[1] = (float)scalar.val[1];
-        val.fval.s[2] = (float)scalar.val[2];
-        val.fval.s[3] = (float)scalar.val[3];
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=float");
-            args.push_back( std::make_pair( sizeof(cl_float) , (void *)&val.fval.s[0] ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=float4");
-            args.push_back( std::make_pair( sizeof(cl_float4) , (void *)&val.fval ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    case 6:
-        val.dval.s[0] = scalar.val[0];
-        val.dval.s[1] = scalar.val[1];
-        val.dval.s[2] = scalar.val[2];
-        val.dval.s[3] = scalar.val[3];
-        switch(dst.oclchannels())
-        {
-        case 1:
-            sprintf(compile_option, "-D GENTYPE=double");
-            args.push_back( std::make_pair( sizeof(cl_double) , (void *)&val.dval.s[0] ));
-            break;
-        case 4:
-            sprintf(compile_option, "-D GENTYPE=double4");
-            args.push_back( std::make_pair( sizeof(cl_double4) , (void *)&val.dval ));
-            break;
-        default:
-            CV_Error(Error::StsUnsupportedFormat, "unsupported channels");
-        }
-        break;
-    default:
-        CV_Error(Error::StsUnsupportedFormat, "unknown depth");
-    }
-#ifdef CL_VERSION_1_2
-    if(dst.offset == 0 && dst.cols == dst.wholecols)
-    {
-        clEnqueueFillBuffer((cl_command_queue)dst.clCxt->oclCommandQueue(), (cl_mem)dst.data, args[0].second, args[0].first, 0, dst.step * dst.rows, 0, NULL, NULL);
-    }
-    else
-    {
-        args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst.data ));
-        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dst.cols ));
-        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dst.rows ));
-        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&step_in_pixel ));
-        args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset_in_pixel));
-        openCLExecuteKernel2(dst.clCxt , &operator_setTo, kernelName, globalThreads,
-                             localThreads, args, -1, -1, compile_option, CLFLUSH);
-    }
-#else
-    args.push_back( std::make_pair( sizeof(cl_mem) , (void *)&dst.data ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dst.cols ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dst.rows ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&step_in_pixel ));
-    args.push_back( std::make_pair( sizeof(cl_int) , (void *)&offset_in_pixel));
-    openCLExecuteKernel2(dst.clCxt , &operator_setTo, kernelName, globalThreads,
-                         localThreads, args, -1, -1, compile_option, CLFLUSH);
-#endif
-}
-
-static oclMat &setTo(oclMat &src, const Scalar &scalar)
-{
-    CV_Assert( src.depth() >= 0 && src.depth() <= 6 );
-    CV_DbgAssert( !src.empty());
-
-    if(src.type() == CV_8UC1)
-    {
-        set_to_withoutmask_run_cus(src, scalar, "set_to_without_mask_C1_D0");
-    }
-    else
-    {
-        set_to_withoutmask_run_cus(src, scalar, "set_to_without_mask");
-    }
-
-    return src;
-}
-
-///////////////////////////////////////////////////////////////////////////
-////////////////////////////////// CopyTo /////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-// static void copy_to_with_mask_cus(const oclMat &src, oclMat &dst, const oclMat &mask, String kernelName)
-// {
-//     CV_DbgAssert( dst.rows == mask.rows && dst.cols == mask.cols &&
-//                   src.rows == dst.rows && src.cols == dst.cols
-//                   && mask.type() == CV_8UC1);
-
-//     std::vector<std::pair<size_t , const void *> > args;
-
-//     String string_types[4][7] = {{"uchar", "char", "ushort", "short", "int", "float", "double"},
-//         {"uchar2", "char2", "ushort2", "short2", "int2", "float2", "double2"},
-//         {"uchar3", "char3", "ushort3", "short3", "int3", "float3", "double3"},
-//         {"uchar4", "char4", "ushort4", "short4", "int4", "float4", "double4"}
-//     };
-//     char compile_option[32];
-//     sprintf(compile_option, "-D GENTYPE=%s", string_types[dst.oclchannels() - 1][dst.depth()].c_str());
-//     size_t localThreads[3] = {16, 16, 1};
-//     size_t globalThreads[3];
-
-//     globalThreads[0] = divUp(dst.cols, localThreads[0]) * localThreads[0];
-//     globalThreads[1] = divUp(dst.rows, localThreads[1]) * localThreads[1];
-//     globalThreads[2] = 1;
-
-//     int dststep_in_pixel = dst.step / dst.elemSize(), dstoffset_in_pixel = dst.offset / dst.elemSize();
-//     int srcstep_in_pixel = src.step / src.elemSize(), srcoffset_in_pixel = src.offset / src.elemSize();
-
-//     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_mem) , (void *)&mask.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 *)&srcstep_in_pixel ));
-//     args.push_back( std::make_pair( sizeof(cl_int) , (void *)&srcoffset_in_pixel ));
-//     args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dststep_in_pixel ));
-//     args.push_back( std::make_pair( sizeof(cl_int) , (void *)&dstoffset_in_pixel ));
-//     args.push_back( std::make_pair( sizeof(cl_int) , (void *)&mask.step ));
-//     args.push_back( std::make_pair( sizeof(cl_int) , (void *)&mask.offset ));
-
-//     openCLExecuteKernel2(dst.clCxt , &operator_copyToM, kernelName, globalThreads,
-//                          localThreads, args, -1, -1, compile_option, CLFLUSH);
-// }
-
-static void copyTo(const oclMat &src, oclMat &m )
-{
-    CV_DbgAssert(!src.empty());
-    m.create(src.size(), src.type());
-    openCLCopyBuffer2D(src.clCxt, m.data, m.step, m.offset,
-                       src.data, src.step, src.cols * src.elemSize(), src.rows, src.offset);
-}
-
 static void pyrdown_run_cus(const oclMat &src, const oclMat &dst)
 {
 
@@ -457,7 +116,6 @@ static void pyrDown_cus(const oclMat &src, oclMat &dst)
     CV_Assert(src.depth() <= CV_32F && src.channels() <= 4);
 
     dst.create((src.rows + 1) / 2, (src.cols + 1) / 2, src.type());
-
     pyrdown_run_cus(src, dst);
 }
 
@@ -516,9 +174,7 @@ static void lkSparse_run(oclMat &I, oclMat &J,
         releaseTexture(JTex);
     }
     else
-    {
         openCLExecuteKernel2(clCxt, &pyrlk_no_image, kernelName, globalThreads, localThreads, args, I.oclchannels(), I.depth(), CLFLUSH);
-    }
 }
 
 void cv::ocl::PyrLKOpticalFlow::sparse(const oclMat &prevImg, const oclMat &nextImg, const oclMat &prevPts, oclMat &nextPts, oclMat &status, oclMat *err)
@@ -527,7 +183,6 @@ void cv::ocl::PyrLKOpticalFlow::sparse(const oclMat &prevImg, const oclMat &next
     {
         nextPts.release();
         status.release();
-        //if (err) err->release();
         return;
     }
 
@@ -556,8 +211,7 @@ void cv::ocl::PyrLKOpticalFlow::sparse(const oclMat &prevImg, const oclMat &next
     multiply(1.0f/(1<<maxLevel)/2.0f, temp1, temp2);
 
     ensureSizeIsEnough(1, prevPts.cols, CV_8UC1, status);
-    //status.setTo(Scalar::all(1));
-    setTo(status, Scalar::all(1));
+    status.setTo(Scalar::all(1));
 
     bool errMat = false;
     if (!err)
@@ -567,7 +221,6 @@ void cv::ocl::PyrLKOpticalFlow::sparse(const oclMat &prevImg, const oclMat &next
     }
     else
         ensureSizeIsEnough(1, prevPts.cols, CV_32FC1, *err);
-    //ensureSizeIsEnough(1, prevPts.cols, CV_32FC1, err);
 
     // build the image pyramids.
     prevPyr_.resize(maxLevel + 1);
@@ -575,19 +228,8 @@ void cv::ocl::PyrLKOpticalFlow::sparse(const oclMat &prevImg, const oclMat &next
 
     if (cn == 1 || cn == 4)
     {
-        //prevImg.convertTo(prevPyr_[0], CV_32F);
-        //nextImg.convertTo(nextPyr_[0], CV_32F);
-        convertTo(prevImg, prevPyr_[0], CV_32F);
-        convertTo(nextImg, nextPyr_[0], CV_32F);
-    }
-    else
-    {
-        //oclMat buf_;
-        //      cvtColor(prevImg, buf_, COLOR_BGR2BGRA);
-        //      buf_.convertTo(prevPyr_[0], CV_32F);
-
-        //      cvtColor(nextImg, buf_, COLOR_BGR2BGRA);
-        //      buf_.convertTo(nextPyr_[0], CV_32F);
+        prevImg.convertTo(prevPyr_[0], CV_32F);
+        nextImg.convertTo(nextPyr_[0], CV_32F);
     }
 
     for (int level = 1; level <= maxLevel; ++level)
@@ -646,11 +288,6 @@ static void lkDense_run(oclMat &I, oclMat &J, oclMat &u, oclMat &v,
         JTex = (cl_mem)J.data;
     }
 
-    //int2 halfWin = {(winSize.width - 1) / 2, (winSize.height - 1) / 2};
-    //const int patchWidth  = 16 + 2 * halfWin.x;
-    //const int patchHeight = 16 + 2 * halfWin.y;
-    //size_t smem_size = 3 * patchWidth * patchHeight * sizeof(int);
-
     std::vector<std::pair<size_t , const void *> > args;
 
     args.push_back( std::make_pair( sizeof(cl_mem), (void *)&ITex ));
@@ -666,12 +303,10 @@ static void lkDense_run(oclMat &I, oclMat &J, oclMat &u, oclMat &v,
     args.push_back( std::make_pair( sizeof(cl_int), (void *)&prevV.step ));
     args.push_back( std::make_pair( sizeof(cl_int), (void *)&I.rows ));
     args.push_back( std::make_pair( sizeof(cl_int), (void *)&I.cols ));
-    //args.push_back( std::make_pair( sizeof(cl_mem), (void *)&(*err).data ));
-    //args.push_back( std::make_pair( sizeof(cl_int), (void *)&(*err).step ));
+
     if (!isImageSupported)
-    {
         args.push_back( std::make_pair( sizeof(cl_int), (void *)&elemCntPerRow ) );
-    }
+
     args.push_back( std::make_pair( sizeof(cl_int), (void *)&winSize.width ));
     args.push_back( std::make_pair( sizeof(cl_int), (void *)&winSize.height ));
     args.push_back( std::make_pair( sizeof(cl_int), (void *)&iters ));
@@ -685,10 +320,7 @@ static void lkDense_run(oclMat &I, oclMat &J, oclMat &u, oclMat &v,
         releaseTexture(JTex);
     }
     else
-    {
-        //printf("Warning: The image2d_t is not supported by the device. Using alternative method!\n");
         openCLExecuteKernel2(clCxt, &pyrlk_no_image, kernelName, globalThreads, localThreads, args, I.oclchannels(), I.depth(), CLFLUSH);
-    }
 }
 
 void cv::ocl::PyrLKOpticalFlow::dense(const oclMat &prevImg, const oclMat &nextImg, oclMat &u, oclMat &v, oclMat *err)
@@ -705,8 +337,7 @@ void cv::ocl::PyrLKOpticalFlow::dense(const oclMat &prevImg, const oclMat &nextI
     nextPyr_.resize(maxLevel + 1);
 
     prevPyr_[0] = prevImg;
-    //nextImg.convertTo(nextPyr_[0], CV_32F);
-    convertTo(nextImg, nextPyr_[0], CV_32F);
+    nextImg.convertTo(nextPyr_[0], CV_32F);
 
     for (int level = 1; level <= maxLevel; ++level)
     {
@@ -718,10 +349,8 @@ void cv::ocl::PyrLKOpticalFlow::dense(const oclMat &prevImg, const oclMat &nextI
     ensureSizeIsEnough(prevImg.size(), CV_32FC1, vPyr_[0]);
     ensureSizeIsEnough(prevImg.size(), CV_32FC1, uPyr_[1]);
     ensureSizeIsEnough(prevImg.size(), CV_32FC1, vPyr_[1]);
-    //uPyr_[1].setTo(Scalar::all(0));
-    //vPyr_[1].setTo(Scalar::all(0));
-    setTo(uPyr_[1], Scalar::all(0));
-    setTo(vPyr_[1], Scalar::all(0));
+    uPyr_[1].setTo(Scalar::all(0));
+    vPyr_[1].setTo(Scalar::all(0));
 
     Size winSize2i(winSize.width, winSize.height);
 
@@ -738,10 +367,8 @@ void cv::ocl::PyrLKOpticalFlow::dense(const oclMat &prevImg, const oclMat &nextI
             idx = idx2;
     }
 
-    //uPyr_[idx].copyTo(u);
-    //vPyr_[idx].copyTo(v);
-    copyTo(uPyr_[idx], u);
-    copyTo(vPyr_[idx], v);
+    uPyr_[idx].copyTo(u);
+    vPyr_[idx].copyTo(v);
 
     clFinish((cl_command_queue)prevImg.clCxt->oclCommandQueue());
 }

diff --git a/modules/ocl/test/test_optflow.cpp b/modules/ocl/test/test_optflow.cpp
index 3b6c480..5d1817e 100644 (file)
--- a/modules/ocl/test/test_optflow.cpp
+++ b/modules/ocl/test/test_optflow.cpp
@@ -251,7 +251,6 @@ TEST_P(Sparse, Mat)
             cv::Point2i b = nextPts_gold[i];
 
             bool eq = std::abs(a.x - b.x) < 1 && std::abs(a.y - b.y) < 1;
-            //float errdiff = std::abs(err[i] - err_gold[i]);
             float errdiff = 0.0f;
 
             if (!eq || errdiff > 1e-1)
@@ -262,12 +261,10 @@ TEST_P(Sparse, Mat)
     double bad_ratio = static_cast<double>(mistmatch) / (nextPts.size());
 
     ASSERT_LE(bad_ratio, 0.02f);
-
 }
 
-INSTANTIATE_TEST_CASE_P(OCL_Video, Sparse, Combine(
-    Values(false, true),
-    Values(false, true)));
+INSTANTIATE_TEST_CASE_P(OCL_Video, Sparse, Combine(Bool(), Bool()));
+
 //////////////////////////////////////////////////////
 // FarnebackOpticalFlow