光流

目录

• 目标
• 光流
  • 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，否则为零。我们迭代地将这些下一个点作为下一步中的前一个点传递。请参见下面的代码

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.push_back(Scalar(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("Frame", 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("Frame", 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 的算法，该算法在 Gunnar Farneback 2003 年的论文“基于多项式展开的两帧运动估计”中进行了解释。

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

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);
      }
  }

请参见下面的结果

图像