new implementation of gpu::PyrLKOpticalFlow::dense (1.5 - 2x faster)

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -1754,7 +1754,6 @@ public:
         winSize = Size(21, 21);
         maxLevel = 3;
         iters = 30;
-        derivLambda = 0.5;
         useInitialFlow = false;
         minEigThreshold = 1e-4f;
         getMinEigenVals = false;
@@ -1769,7 +1768,6 @@ public:
     Size winSize;
     int maxLevel;
     int iters;
-    double derivLambda;
     bool useInitialFlow;
     float minEigThreshold;
     bool getMinEigenVals;

modules/gpu/perf/perf_video.cpp

@@ -208,11 +208,18 @@ INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(
 //////////////////////////////////////////////////////
 // PyrLKOpticalFlowDense
 
-GPU_PERF_TEST_1(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo)
+IMPLEMENT_PARAM_CLASS(Levels, int)
+IMPLEMENT_PARAM_CLASS(Iters, int)
+
+GPU_PERF_TEST(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo, WinSize, Levels, Iters)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
 
+    int winSize = GET_PARAM(1);
+    int levels = GET_PARAM(2);
+    int iters = GET_PARAM(3);
+
     cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame0_host.empty());
 
@@ -226,9 +233,13 @@ GPU_PERF_TEST_1(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo)
 
     cv::gpu::PyrLKOpticalFlow pyrLK;
 
+    pyrLK.winSize = cv::Size(winSize, winSize);
+    pyrLK.maxLevel = levels - 1;
+    pyrLK.iters = iters;
+
     pyrLK.dense(frame0, frame1, u, v);
 
-    declare.time(10);
+    declare.time(30);
 
     TEST_CYCLE()
     {
@@ -236,7 +247,11 @@ GPU_PERF_TEST_1(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowDense, ALL_DEVICES);
+INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowDense, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(WinSize(3), WinSize(5), WinSize(7), WinSize(9), WinSize(13), WinSize(17), WinSize(21)),
+    testing::Values(Levels(1), Levels(2), Levels(3)),
+    testing::Values(Iters(1), Iters(10))));
 
 //////////////////////////////////////////////////////
 // FarnebackOpticalFlowTest

modules/gpu/src/pyrlk.cpp

@@ -66,8 +66,8 @@ namespace cv { namespace gpu { namespace device
             const float2* prevPts, float2* nextPts, uchar* status, float* err, bool GET_MIN_EIGENVALS, int ptcount,
             int level, dim3 block, dim3 patch, cudaStream_t stream = 0);
 
-        void lkDense_gpu(DevMem2Db I, DevMem2Db J, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy,
-            DevMem2Df u, DevMem2Df v, DevMem2Df* err, bool GET_MIN_EIGENVALS, cudaStream_t stream = 0);
+        void lkDense_gpu(DevMem2Db I, DevMem2Df J, DevMem2Df u, DevMem2Df v, DevMem2Df prevU, DevMem2Df prevV,
+                         DevMem2Df err, int2 winSize, cudaStream_t stream = 0);
     }
 }}}
 
@@ -160,16 +160,11 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next
         return;
     }
 
-    derivLambda = std::min(std::max(derivLambda, 0.0), 1.0);
-
-    iters = std::min(std::max(iters, 0), 100);
-
     const int cn = prevImg.channels();
 
     dim3 block, patch;
-    calcPatchSize(winSize, cn, block, patch, isDeviceArch11_);   
+    calcPatchSize(winSize, cn, block, patch, isDeviceArch11_);
 
-    CV_Assert(derivLambda >= 0);
     CV_Assert(maxLevel >= 0 && winSize.width > 2 && winSize.height > 2);
     CV_Assert(prevImg.size() == nextImg.size() && prevImg.type() == nextImg.type());
     CV_Assert(patch.x > 0 && patch.x < 6 && patch.y > 0 && patch.y < 6);
@@ -227,80 +222,53 @@ void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat& prevImg, const GpuMat& nextI
 {
     using namespace cv::gpu::device::pyrlk;
 
-    derivLambda = std::min(std::max(derivLambda, 0.0), 1.0);
-
-    iters = std::min(std::max(iters, 0), 100);
-
     CV_Assert(prevImg.type() == CV_8UC1);
     CV_Assert(prevImg.size() == nextImg.size() && prevImg.type() == nextImg.type());
-    CV_Assert(derivLambda >= 0);
-    CV_Assert(maxLevel >= 0 && winSize.width > 2 && winSize.height > 2);
-
-    if (useInitialFlow)
-    {
-        CV_Assert(u.size() == prevImg.size() && u.type() == CV_32FC1);
-        CV_Assert(v.size() == prevImg.size() && v.type() == CV_32FC1);
-    }
-    else
-    {
-        u.create(prevImg.size(), CV_32FC1);
-        v.create(prevImg.size(), CV_32FC1);
-
-        u.setTo(Scalar::all(0));
-        v.setTo(Scalar::all(0));
-    }
+    CV_Assert(maxLevel >= 0);
+    CV_Assert(winSize.width > 2 && winSize.height > 2);
 
     if (err)
         err->create(prevImg.size(), CV_32FC1);
 
     // build the image pyramids.
-    // we pad each level with +/-winSize.{width|height}
-    // pixels to simplify the further patch extraction.
 
-    buildImagePyramid(prevImg, prevPyr_, true);
-    buildImagePyramid(nextImg, nextPyr_, true);
-    buildImagePyramid(u, uPyr_, false);
-    buildImagePyramid(v, vPyr_, false);
+    buildImagePyramid(prevImg, prevPyr_, false);
 
-    // dI/dx ~ Ix, dI/dy ~ Iy
+    nextPyr_.resize(maxLevel + 1);
+    nextImg.convertTo(nextPyr_[0], CV_32F);
+    for (int level = 1; level <= maxLevel; ++level)
+        pyrDown(nextPyr_[level - 1], nextPyr_[level]);
+
+    uPyr_.resize(2);
+    vPyr_.resize(2);
 
-    ensureSizeIsEnough(prevImg.rows + winSize.height * 2, prevImg.cols + winSize.width * 2, CV_16SC1, dx_buf_);
-    ensureSizeIsEnough(prevImg.rows + winSize.height * 2, prevImg.cols + winSize.width * 2, CV_16SC1, dy_buf_);
+    ensureSizeIsEnough(prevImg.size(), CV_32FC1, uPyr_[0]);
+    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));
 
-    loadConstants(1, minEigThreshold, make_int2(winSize.width, winSize.height), iters);
+    int2 winSize2i = make_int2(winSize.width, winSize.height);
+    loadConstants(1, minEigThreshold, winSize2i, iters);
 
     DevMem2Df derr = err ? *err : DevMem2Df();
 
+    int idx = 0;
+
     for (int level = maxLevel; level >= 0; level--)
     {
-        Size imgSize = prevPyr_[level].size();
-
-        GpuMat dxWhole(imgSize.height + winSize.height * 2, imgSize.width + winSize.width * 2, dx_buf_.type(), dx_buf_.data, dx_buf_.step);
-        GpuMat dyWhole(imgSize.height + winSize.height * 2, imgSize.width + winSize.width * 2, dy_buf_.type(), dy_buf_.data, dy_buf_.step);
-        dxWhole.setTo(Scalar::all(0));
-        dyWhole.setTo(Scalar::all(0));
-        GpuMat dIdx = dxWhole(Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));
-        GpuMat dIdy = dyWhole(Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));
+        int idx2 = (idx + 1) & 1;
 
-        calcSharrDeriv(prevPyr_[level], dIdx, dIdy);
+        lkDense_gpu(prevPyr_[level], nextPyr_[level], uPyr_[idx], vPyr_[idx], uPyr_[idx2], vPyr_[idx2],
+            level == 0 ? derr : DevMem2Df(), winSize2i);
 
-        lkDense_gpu(prevPyr_[level], nextPyr_[level], dIdx, dIdy, uPyr_[level], vPyr_[level],
-            level == 0 && err ? &derr : 0, getMinEigenVals);
-
-        if (level == 0)
-        {
-            uPyr_[0].copyTo(u);
-            vPyr_[0].copyTo(v);
-        }
-        else
-        {
-            resize(uPyr_[level], uPyr_[level - 1], uPyr_[level - 1].size());
-            resize(vPyr_[level], vPyr_[level - 1], vPyr_[level - 1].size());
-
-            multiply(uPyr_[level - 1], Scalar::all(2), uPyr_[level - 1]);
-            multiply(vPyr_[level - 1], Scalar::all(2), vPyr_[level - 1]);
-        }
+        if (level > 0)
+            idx = idx2;
     }
+
+    uPyr_[idx].copyTo(u);
+    vPyr_[idx].copyTo(v);
 }
 
 #endif /* !defined (HAVE_CUDA) */

samples/gpu/pyrlk_optical_flow.cpp

@@ -159,7 +159,6 @@ int main(int argc, const char* argv[])
         "{ win_size     | win_size       | 21    | specify windows size [PyrLK] }"
         "{ max_level    | max_level      | 3     | specify max level [PyrLK] }"
         "{ iters        | iters          | 30    | specify iterations count [PyrLK] }"
-        "{ deriv_lambda | deriv_lambda   | 0.5   | specify deriv lambda [PyrLK] }"
         "{ points       | points         | 4000  | specify points count [GoodFeatureToTrack] }"
         "{ min_dist     | min_dist       | 0     | specify minimal distance between points [GoodFeatureToTrack] }";
 
@@ -186,7 +185,6 @@ int main(int argc, const char* argv[])
     int winSize = cmd.get<int>("win_size");
     int maxLevel = cmd.get<int>("max_level");
     int iters = cmd.get<int>("iters");
-    double derivLambda = cmd.get<double>("deriv_lambda");
     int points = cmd.get<int>("points");
     double minDist = cmd.get<double>("min_dist");
 
@@ -235,7 +233,6 @@ int main(int argc, const char* argv[])
     d_pyrLK.winSize.height = winSize;
     d_pyrLK.maxLevel = maxLevel;
     d_pyrLK.iters = iters;
-    d_pyrLK.derivLambda = derivLambda;
 
     GpuMat d_frame0(frame0);
     GpuMat d_frame1(frame1);