光流

目录

• 目标
• 光流
  • Lucas-Kanade 方法
• OpenCV 中的 Lucas-Kanade 光流
• OpenCV 中的稠密光流

上一个教程： 均值漂移和 Camshift
下一个教程： 级联分类器

目标

在本章中，

• 我们将理解光流的概念及其使用 Lucas-Kanade 方法进行估计。
• 我们将使用诸如 cv.calcOpticalFlowPyrLK() 等函数来跟踪视频中的特征点。
• 我们将使用 cv.calcOpticalFlowFarneback() 方法创建稠密光流场。

光流

光流是由于物体或摄像机的移动，图像对象在两个连续帧之间出现的运动模式。它是一个二维矢量场，其中每个矢量都是一个位移矢量，显示了点从第一帧到第二帧的移动。考虑下图（图片来源：维基百科光流文章）。

图像

它显示了一个球在 5 个连续帧中移动。箭头显示了它的位移矢量。光流在许多领域都有应用，例如：

• 运动结构
• 视频压缩
• 视频稳定化...

光流基于几个假设：

1. 对象像素强度在连续帧之间不发生变化。
2. 相邻像素具有相似的运动。

考虑第一帧中的一个像素 \(I(x,y,t)\)（请注意这里添加了一个新的维度，时间。之前我们只处理图像，所以不需要时间）。它在 \(dt\) 时间后的下一帧中移动了 \((dx,dy)\) 的距离。由于这些像素相同且强度不变，我们可以说：

\[I(x,y,t) = I(x+dx, y+dy, t+dt)\]

然后对右侧进行泰勒级数近似，去除相同项并除以 \(dt\) 得到以下方程：

\[f_x u + f_y v + f_t = 0 \;\]

其中

\[f_x = \frac{\partial f}{\partial x} \; ; \; f_y = \frac{\partial f}{\partial y}\]

\[u = \frac{dx}{dt} \; ; \; v = \frac{dy}{dt}\]

上述方程称为光流方程。其中，我们可以找到 \(f_x\) 和 \(f_y\)，它们是图像梯度。同样，\(f_t\) 是沿时间的梯度。但 \((u,v)\) 是未知数。我们无法用两个未知变量求解这一个方程。因此，提供了几种方法来解决此问题，其中之一是 Lucas-Kanade 方法。

Lucas-Kanade 方法

我们之前看到一个假设，即所有相邻像素都将具有相似的运动。Lucas-Kanade 方法围绕该点取一个 3x3 的补丁。因此，所有 9 个点都具有相同的运动。我们可以找到这 9 个点的 \((f_x, f_y, f_t)\)。所以现在我们的问题变成了求解 9 个方程和两个未知变量，这是一个过定问题。通过最小二乘拟合方法可以获得更好的解决方案。下面是最终解决方案，它是一个两方程两未知数问题，求解即可得到答案。

\[\begin{bmatrix} u \\ v \end{bmatrix} = \begin{bmatrix} \sum_{i}{f_{x_i}}^2 & \sum_{i}{f_{x_i} f_{y_i} } \\ \sum_{i}{f_{x_i} f_{y_i}} & \sum_{i}{f_{y_i}}^2 \end{bmatrix}^{-1} \begin{bmatrix} - \sum_{i}{f_{x_i} f_{t_i}} \\ - \sum_{i}{f_{y_i} f_{t_i}} \end{bmatrix}\]

( 将逆矩阵与 Harris 角点检测器进行比较。它表明角点是更好的跟踪点。)

因此，从用户的角度来看，这个想法很简单，我们给出一些点来跟踪，我们收到这些点的光流向量。但又出现了一些问题。到目前为止，我们处理的是小运动，所以当运动很大时，它就会失败。为了解决这个问题，我们使用金字塔。当我们在金字塔中向上移动时，小运动被消除，大运动变成小运动。因此，通过在那里应用 Lucas-Kanade，我们得到了光流以及尺度。

OpenCV 中的 Lucas-Kanade 光流

OpenCV 在一个函数 cv.calcOpticalFlowPyrLK() 中提供了所有这些功能。在这里，我们创建一个简单的应用程序来跟踪视频中的一些点。为了确定这些点，我们使用 cv.goodFeaturesToTrack()。我们获取第一帧，检测其中的一些 Shi-Tomasi 角点，然后我们使用 Lucas-Kanade 光流迭代跟踪这些点。对于函数 cv.calcOpticalFlowPyrLK()，我们传入上一帧、上一点和下一帧。它返回下一点以及一些状态数字，如果找到下一点，则状态为 1，否则为 0。我们在下一步中迭代地将这些下一点作为上一点传入。请参见下面的代码

C++

• 可下载代码：点击此处
• 代码概览

  #include <iostream>
  #include <opencv2/core.hpp>
  #include <opencv2/highgui.hpp>
  #include <opencv2/imgproc.hpp>
  #include <opencv2/videoio.hpp>
  #include <opencv2/video.hpp>
   
  using namespace cv;
  using namespace std;
   
  int main(int argc, char **argv)
  {
      const string about =
          "此示例演示了 Lucas-Kanade 光流计算。\n"
          "示例文件可以从以下位置下载：\n"
          " https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4";
      const string keys =
          "{ h help | | 打印此帮助信息 }"
          "{ @image | vtest.avi | 图像文件路径 }";
      CommandLineParser parser(argc, argv, keys);
  parser.about(about);
      if (parser.has("help"))
      {
  parser.printMessage();
          return 0;
      }
      string filename = samples::findFile(parser.get<string>("@image"));
      if (!parser.check())
      {
  parser.printErrors();
          return 0;
      }
   
      VideoCapture capture(filename);
      if (!capture.isOpened()){
          //打开视频输入时出错
  cerr << "无法打开文件！" << endl;
          return 0;
      }
   
      // 创建一些随机颜色
  vector<Scalar> colors;
      RNG rng;
      for(int i = 0; i < 100; i++)
      {
          int r = rng.uniform(0, 256);
          int g = rng.uniform(0, 256);
          int b = rng.uniform(0, 256);
  colors.emplace_back(r,g,b);
      }
   
      Mat old_frame, old_gray;
  vector<Point2f> p0, p1;
   
      // 获取第一帧并在其中找到角点
  capture >> old_frame;
      cvtColor(old_frame, old_gray, COLOR_BGR2GRAY);
      goodFeaturesToTrack(old_gray, p0, 100, 0.3, 7, Mat(), 7, false, 0.04);
   
      // 创建一个用于绘图的掩膜图像
      Mat mask = Mat::zeros(old_frame.size(), old_frame.type());
   
      while(true){
          Mat frame, frame_gray;
   
  capture >> frame;
          if (frame.empty())
              break;
          cvtColor(frame, frame_gray, COLOR_BGR2GRAY);
   
          // 计算光流
  vector<uchar> status;
  vector<float> err;
          TermCriteria criteria = TermCriteria((TermCriteria::COUNT) + (TermCriteria::EPS), 10, 0.03);
          calcOpticalFlowPyrLK(old_gray, frame_gray, p0, p1, status, err, Size(15,15), 2, criteria);
   
  vector<Point2f> good_new;
          for(uint i = 0; i < p0.size(); i++)
          {
              // 选择好的点
              if(status[i] == 1) {
  good_new.push_back(p1[i]);
                  // 绘制轨迹
                  line(mask,p1[i], p0[i], colors[i], 2);
                  circle(frame, p1[i], 5, colors[i], -1);
              }
          }
          Mat img;
          add(frame, mask, img);
   
          imshow("帧", img);
   
          int keyboard = waitKey(30);
          if (keyboard == 'q' || keyboard == 27)
              break;
   
          // 现在更新上一帧和上一点
  old_gray = frame_gray.clone();
  p0 = good_new;
      }
  }

Python

• 可下载代码：点击此处
• 代码概览

  import numpy as np
  import cv2 as cv
  import argparse
   
  parser = argparse.ArgumentParser(description='此示例演示了 Lucas-Kanade 光流计算。 \
  示例文件可以从以下位置下载： \
  https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
  parser.add_argument('image', type=str, help='图像文件路径')
  args = parser.parse_args()
   
  cap = cv.VideoCapture(args.image)
   
  # ShiTomasi 角点检测参数
  feature_params = dict( maxCorners = 100,
  qualityLevel = 0.3,
  minDistance = 7,
  blockSize = 7 )
   
  # Lucas-Kanade 光流参数
  lk_params = dict( winSize = (15, 15),
  maxLevel = 2,
  criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
   
  # 创建一些随机颜色
  color = np.random.randint(0, 255, (100, 3))
   
  # 获取第一帧并在其中找到角点
  ret, old_frame = cap.read()
  old_gray = cv.cvtColor(old_frame, cv.COLOR_BGR2GRAY)
  p0 = cv.goodFeaturesToTrack(old_gray, mask = None, **feature_params)
   
  # 创建一个用于绘图的掩膜图像
  mask = np.zeros_like(old_frame)
   
  while(1)
  ret, frame = cap.read()
      if not ret
  print('没有抓取到帧！')
          break
   
  frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
   
      # 计算光流
  p1, st, err = cv.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
   
      # 选择好的点
      if p1 is not None
  good_new = p1[st==1]
  good_old = p0[st==1]
   
      # 绘制轨迹
      for i, (new, old) in enumerate(zip(good_new, good_old))
  a, b = new.ravel()
  c, d = old.ravel()
  mask = cv.line(mask, (int(a), int(b)), (int(c), int(d)), color[i].tolist(), 2)
  frame = cv.circle(frame, (int(a), int(b)), 5, color[i].tolist(), -1)
  img = cv.add(frame, mask)
   
      cv.imshow('frame', img)
  k = cv.waitKey(30) & 0xff
      if k == 27
          break
   
      # 现在更新上一帧和上一点
  old_gray = frame_gray.copy()
  p0 = good_new.reshape(-1, 1, 2)
   
  cv.destroyAllWindows()

Java

• 可下载代码：点击此处
• 代码概览

  import java.util.ArrayList;
  import java.util.Random;
  import org.opencv.core.*;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgproc.Imgproc;
  import org.opencv.video.Video;
  import org.opencv.videoio.VideoCapture;
   
  class OptFlow {
      public void run(String[] args) {
  String filename = args[0];
  VideoCapture capture = new VideoCapture(filename);
          if (!capture.isOpened()) {
  System.out.println("无法打开此文件");
  System.exit(-1);
          }
   
   
          // 创建一些随机颜色
  Scalar[] colors = new Scalar[100];
  Random rng = new Random();
          for (int i = 0 ; i < 100 ; i++) {
              int r = rng.nextInt(256);
              int g = rng.nextInt(256);
              int b = rng.nextInt(256);
  colors[i] = new Scalar(r, g, b);
          }
   
  Mat old_frame = new Mat() , old_gray = new Mat();
   
          // 由于函数 Imgproc.goodFeaturesToTrack 需要 MatofPoint
          // 因此首先将 p0MatofPoint 传递给函数，然后将其转换为 MatOfPoint2f
  MatOfPoint p0MatofPoint = new MatOfPoint();
  capture.read(old_frame);
  Imgproc.cvtColor(old_frame, old_gray, Imgproc.COLOR_BGR2GRAY);
  Imgproc.goodFeaturesToTrack(old_gray, p0MatofPoint,100,0.3,7, new Mat(),7,false,0.04);
   
  MatOfPoint2f p0 = new MatOfPoint2f(p0MatofPoint.toArray()) , p1 = new MatOfPoint2f();
   
          // 创建一个用于绘图的掩膜图像
  Mat mask = Mat.zeros(old_frame.size(), old_frame.type());
   
          while (true) {
  Mat frame = new Mat(), frame_gray = new Mat();
  capture.read(frame);
              if (frame.empty()) {
                  break;
              }
   
  Imgproc.cvtColor(frame, frame_gray, Imgproc.COLOR_BGR2GRAY);
   
              // 计算光流
  MatOfByte status = new MatOfByte();
  MatOfFloat err = new MatOfFloat();
  TermCriteria criteria = new TermCriteria(TermCriteria.COUNT + TermCriteria.EPS,10,0.03);
  Video.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, p1, status, err, new Size(15,15),2, criteria);
   
              byte StatusArr[] = status.toArray();
  Point p0Arr[] = p0.toArray();
  Point p1Arr[] = p1.toArray();
  ArrayList<Point> good_new = new ArrayList<>();
   
              for (int i = 0; i<StatusArr.length ; i++ ) {
                  if (StatusArr[i] == 1) {
  good_new.add(p1Arr[i]);
  Imgproc.line(mask, p1Arr[i], p0Arr[i], colors[i],2);
  Imgproc.circle(frame, p1Arr[i],5, colors[i],-1);
                  }
              }
   
  Mat img = new Mat();
  Core.add(frame, mask, img);
   
  HighGui.imshow("帧", img);
   
              int keyboard = HighGui.waitKey(30);
              if (keyboard == 'q' || keyboard == 27) {
                  break;
              }
   
              // 现在更新上一帧和上一点
  old_gray = frame_gray.clone();
              Point[] good_new_arr = new Point[good_new.size()];
  good_new_arr = good_new.toArray(good_new_arr);
  p0 = new MatOfPoint2f(good_new_arr);
          }
  System.exit(0);
      }
  }
   
  public class OpticalFlowDemo {
      public static void main(String[] args) {
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
          new OptFlow().run(args);
      }
  }

(此代码未检查下一个关键点的正确性。因此，即使图像中任何特征点消失，光流也有可能找到可能与其接近的下一个点。因此，对于鲁棒的跟踪，应该在特定时间间隔内检测角点。OpenCV 示例提供了一个这样的示例，它每 5 帧查找一次特征点。它还对获得的光流点进行反向检查，以仅选择好的点。请查看 samples/python/lk_track.py）。

请看我们得到的结果

图像

OpenCV 中的稠密光流

Lucas-Kanade 方法计算稀疏特征集的光流（在我们的例子中，是使用 Shi-Tomasi 算法检测到的角点）。OpenCV 提供了另一种算法来查找稠密光流。它计算帧中所有点的光流。它基于 Gunnar Farneback 在 2003 年的“基于多项式展开的两帧运动估计”中解释的算法。

以下示例演示了如何使用上述算法查找稠密光流。我们得到一个带有光流矢量 \((u,v)\) 的双通道数组。我们计算它们的幅度和方向。为了更好地可视化，我们对结果进行颜色编码。方向对应于图像的色调值。幅度对应于亮度平面。请参见下面的代码

C++

• 可下载代码：点击此处
• 代码概览

  #include <iostream>
  #include <opencv2/core.hpp>
  #include <opencv2/highgui.hpp>
  #include <opencv2/imgproc.hpp>
  #include <opencv2/videoio.hpp>
  #include <opencv2/video.hpp>
   
  using namespace cv;
  using namespace std;
   
  int main()
  {
      VideoCapture capture(samples::findFile("vtest.avi"));
      if (!capture.isOpened()){
          //打开视频输入时出错
  cerr << "无法打开文件！" << endl;
          return 0;
      }
   
      Mat frame1, prvs;
  capture >> frame1;
  cvtColor(frame1, prvs, COLOR_BGR2GRAY);
   
      while(true){
          Mat frame2, next;
  capture >> frame2;
          if (frame2.empty())
              break;
  cvtColor(frame2, next, COLOR_BGR2GRAY);
   
          Mat flow(prvs.size(), CV_32FC2);
  calcOpticalFlowFarneback(prvs, next, flow, 0.5, 3, 15, 3, 5, 1.2, 0);
   
          // 可视化
          Mat flow_parts[2];
  split(flow, flow_parts);
          Mat magnitude, angle, magn_norm;
  cartToPolar(flow_parts[0], flow_parts[1], magnitude, angle, true);
  normalize(magnitude, magn_norm, 0.0f, 1.0f, NORM_MINMAX);
  angle *= ((1.f / 360.f) * (180.f / 255.f));
   
          // 构建 hsv 图像
          Mat _hsv[3], hsv, hsv8, bgr;
  _hsv[0] = angle;
  _hsv[1] = Mat::ones(angle.size(), CV_32F);
  _hsv[2] = magn_norm;
  merge(_hsv, 3, hsv);
  hsv.convertTo(hsv8, CV_8U, 255.0);
  cvtColor(hsv8, bgr, COLOR_HSV2BGR);
   
  imshow("frame2", bgr);
   
          int keyboard = waitKey(30);
          if (keyboard == 'q' || keyboard == 27)
              break;
   
  prvs = next;
      }
  }

Python

• 可下载代码：点击此处
• 代码概览

  import numpy as np
  import cv2 as cv
  cap = cv.VideoCapture(cv.samples.findFile("vtest.avi"))
  ret, frame1 = cap.read()
  prvs = cv.cvtColor(frame1, cv.COLOR_BGR2GRAY)
  hsv = np.zeros_like(frame1)
  hsv[..., 1] = 255
  while(1)
  ret, frame2 = cap.read()
      if not ret
  print('没有抓取到帧！')
          break
   
  next = cv.cvtColor(frame2, cv.COLOR_BGR2GRAY)
  flow = cv.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
  mag, ang = cv.cartToPolar(flow[..., 0], flow[..., 1])
  hsv[..., 0] = ang*180/np.pi/2
  hsv[..., 2] = cv.normalize(mag, None, 0, 255, cv.NORM_MINMAX)
  bgr = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
      cv.imshow('frame2', bgr)
  k = cv.waitKey(30) & 0xff
      if k == 27
          break
      elif k == ord('s')
          cv.imwrite('opticalfb.png', frame2)
          cv.imwrite('opticalhsv.png', bgr)
  prvs = next
   
  cv.destroyAllWindows()

Java

• 可下载代码：点击此处
• 代码概览

  import java.util.ArrayList;
  import org.opencv.core.*;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgproc.Imgproc;
  import org.opencv.video.Video;
  import org.opencv.videoio.VideoCapture;
   
   
  class OptFlowDense {
      public void run(String[] args) {
  String filename = args[0];
  VideoCapture capture = new VideoCapture(filename);
          if (!capture.isOpened()) {
              //打开视频输入时出错
  System.out.println("无法打开文件！");
  System.exit(-1);
          }
   
  Mat frame1 = new Mat() , prvs = new Mat();
  capture.read(frame1);
  Imgproc.cvtColor(frame1, prvs, Imgproc.COLOR_BGR2GRAY);
   
          while (true) {
  Mat frame2 = new Mat(), next = new Mat();
  capture.read(frame2);
              if (frame2.empty()) {
                  break;
              }
  Imgproc.cvtColor(frame2, next, Imgproc.COLOR_BGR2GRAY);
   
  Mat flow = new Mat(prvs.size(), CvType.CV_32FC2);
  Video.calcOpticalFlowFarneback(prvs, next, flow,0.5,3,15,3,5,1.2,0);
   
              // 可视化
  ArrayList<Mat> flow_parts = new ArrayList<>(2);
  Core.split(flow, flow_parts);
  Mat magnitude = new Mat(), angle = new Mat(), magn_norm = new Mat();
  Core.cartToPolar(flow_parts.get(0), flow_parts.get(1), magnitude, angle,true);
  Core.normalize(magnitude, magn_norm,0.0,1.0, Core.NORM_MINMAX);
              float factor = (float) ((1.0/360.0)*(180.0/255.0));
  Mat new_angle = new Mat();
  Core.multiply(angle, new Scalar(factor), new_angle);
   
              // 构建 hsv 图像
  ArrayList<Mat> _hsv = new ArrayList<>() ;
  Mat hsv = new Mat(), hsv8 = new Mat(), bgr = new Mat();
   
  _hsv.add(new_angle);
  _hsv.add(Mat.ones(angle.size(), CvType.CV_32F));
  _hsv.add(magn_norm);
  Core.merge(_hsv, hsv);
  hsv.convertTo(hsv8, CvType.CV_8U, 255.0);
  Imgproc.cvtColor(hsv8, bgr, Imgproc.COLOR_HSV2BGR);
   
  HighGui.imshow("frame2", bgr);
   
              int keyboard = HighGui.waitKey(30);
              if (keyboard == 'q' || keyboard == 27) {
                  break;
              }
  prvs = next;
          }
  System.exit(0);
      }
  }
   
  public class OpticalFlowDenseDemo {
      public static void main(String[] args) {
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
          new OptFlowDense().run(args);
      }
  }

请看下面的结果

图像