オプティカルフロー

目次

• 目的
• Optical Flow
  • Lucas-Kanade 法
• OpenCV での Lucas-Kanade オプティカルフロー
• OpenCV での密なオプティカルフロー

前のチュートリアル: MeanshiftとCamshift
次のチュートリアル: カスケード分類器

目的

本章では、

• オプティカルフローの概念と、Lucas-Kanade 法を用いたその推定について理解する。
• cv.calcOpticalFlowPyrLK() のような関数を使って、動画中の特徴点を追跡する。
• cv.calcOpticalFlowFarneback() メソッドを使って、密なオプティカルフロー場を生成する。

オプティカルフロー

オプティカルフローとは、物体やカメラの動きによって生じる、連続する2枚のフレーム間での画像中の物体の見かけの動きのパターンである。これは2次元のベクトル場であり、各ベクトルは最初のフレームから2番目のフレームへの点の移動を示す変位ベクトルである。下の画像を見てほしい(画像提供: オプティカルフローに関する Wikipedia の記事)。

image

これは連続する5枚のフレーム中をボールが移動している様子を示している。矢印はその変位ベクトルを表す。オプティカルフローは次のような分野で多くの応用がある:

• Structure from Motion
• 動画圧縮
• 動画の手ブレ補正 ...

オプティカルフローはいくつかの仮定の上に成り立つ:

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)\) は未知である。この1本の方程式を2つの未知変数について解くことはできない。そこでこの問題を解くためにいくつかの手法が提供されており、その1つが Lucas-Kanade である。

Lucas-Kanade 法

先ほど、近傍のピクセルはすべて同様の動きをするという仮定を見た。Lucas-Kanade 法では、対象点の周囲の 3x3 のパッチを取る。したがって9個の点はすべて同じ動きをする。これら9個の点について \((f_x, f_y, f_t)\) を求めることができる。こうして問題は、2つの未知変数を持つ9本の方程式を解くことになり、これは過剰決定系である。より良い解は最小二乗法によって得られる。以下が最終的な解であり、これは未知数2つ・方程式2つの問題となっていて、解いて答えを得る。

\[\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 はこれらすべてを1つの関数 cv.calcOpticalFlowPyrLK() で提供している。ここでは、動画中のいくつかの点を追跡する簡単なアプリケーションを作成する。追跡する点を決めるために cv.goodFeaturesToTrack() を使う。最初のフレームを取得し、その中で Shi-Tomasi コーナー点をいくつか検出し、それらの点を Lucas-Kanade オプティカルフローを使って反復的に追跡する。関数 cv.calcOpticalFlowPyrLK() には、前のフレーム、前の点、次のフレームを渡す。この関数は次の点を返すとともに、いくつかのステータス値を返す。ステータス値は、次の点が見つかった場合は 1、そうでない場合は 0 となる。これらの次の点を、次のステップで前の点として反復的に渡していく。以下のコードを参照してほしい。

C++

• ダウンロード可能なコード: こちらをクリック
• Code at glance:

  #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 =
   "This sample demonstrates Lucas-Kanade Optical Flow calculation.\n"
   "The example file can be downloaded from:\n"
   " https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4";
   const string keys =
   "{ h help | | print this help message }"
   "{ @image | vtest.avi | path to image file }";
   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()){
   //error in opening the video input
   cerr << "Unable to open file!" << endl;
   return 0;
   }
   
   // Create some random colors
   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;
   
   // Take first frame and find corners in it
   capture >> old_frame;
   cvtColor(old_frame, old_gray, COLOR_BGR2GRAY);
   goodFeaturesToTrack(old_gray, p0, 100, 0.3, 7, Mat(), 7, false, 0.04);
   
   // Create a mask image for drawing purposes
   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);
   
   // calculate optical flow
   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++)
   {
   // Select good points
   if(status[i] == 1) {
   good_new.push_back(p1[i]);
   // draw the tracks
   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;
   
   // Now update the previous frame and previous points
   old_gray = frame_gray.clone();
   p0 = good_new;
   }
  }

Python

• ダウンロード可能なコード: こちらをクリック
• Code at glance:

  import numpy as np
  import cv2 as cv
  import argparse
   
  parser = argparse.ArgumentParser(description='This sample demonstrates Lucas-Kanade Optical Flow calculation. \
   The example file can be downloaded from: \
   https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
  parser.add_argument('image', type=str, help='path to image file')
  args = parser.parse_args()
   
  cap = cv.VideoCapture(args.image)
   
  # params for ShiTomasi corner detection
  feature_params = dict( maxCorners = 100,
   qualityLevel = 0.3,
   minDistance = 7,
   blockSize = 7 )
   
  # Parameters for lucas kanade optical flow
  lk_params = dict( winSize = (15, 15),
   maxLevel = 2,
   criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
   
  # Create some random colors
  color = np.random.randint(0, 255, (100, 3))
   
  # Take first frame and find corners in it
  ret, old_frame = cap.read()
  old_gray = cv.cvtColor(old_frame, cv.COLOR_BGR2GRAY)
  p0 = cv.goodFeaturesToTrack(old_gray, mask = None, **feature_params)
   
  # Create a mask image for drawing purposes
  mask = np.zeros_like(old_frame)
   
  while(1):
   ret, frame = cap.read()
   if not ret:
   print('No frames grabbed!')
   break
   
   frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
   
   # calculate optical flow
   p1, st, err = cv.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
   
   # Select good points
   if p1 is not None:
   good_new = p1[st==1]
   good_old = p0[st==1]
   
   # draw the tracks
   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
   
   # Now update the previous frame and previous points
   old_gray = frame_gray.copy()
   p0 = good_new.reshape(-1, 1, 2)
   
  cv.destroyAllWindows()

Java

• ダウンロード可能なコード: こちらをクリック
• Code at glance:

  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("Unable to open this file");
   System.exit(-1);
   }
   
   
   // Create some random colors
   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();
   
   // Since the function Imgproc.goodFeaturesToTrack requires MatofPoint
   // therefore first p0MatofPoint is passed to the function and then converted to 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();
   
   // Create a mask image for drawing purposes
   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);
   
   // calculate optical flow
   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;
   }
   
   // Now update the previous frame and previous points
   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 を参照してほしい。)

得られた結果を見てみよう。

image

OpenCV での密なオプティカルフロー

Lucas-Kanade 法は、疎な特徴点集合(この例では Shi-Tomasi アルゴリズムで検出したコーナー)についてオプティカルフローを計算する。OpenCV は密なオプティカルフローを求める別のアルゴリズムも提供している。これはフレーム中のすべての点についてオプティカルフローを計算する。これは Gunnar Farneback のアルゴリズムに基づいており、2003年に Gunnar Farneback による "Two-Frame Motion Estimation Based on Polynomial Expansion" で説明されている。

以下のサンプルは、上記のアルゴリズムを使って密なオプティカルフローを求める方法を示している。オプティカルフローベクトル \((u,v)\) を持つ2チャンネルの配列が得られる。その大きさと方向を求める。結果を見やすくするために色分けする。方向は画像の色相 (Hue) 値に対応する。大きさは明度 (Value) 面に対応する。以下のコードを参照してほしい。

C++

• ダウンロード可能なコード: こちらをクリック
• Code at glance:

  #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()){
   //error in opening the video input
   cerr << "Unable to open file!" << 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);
   
   // visualization
   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));
   
   //build hsv image
   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

• ダウンロード可能なコード: こちらをクリック
• Code at glance:

  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('No frames grabbed!')
   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

• ダウンロード可能なコード: こちらをクリック
• Code at glance:

  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()) {
   //error in opening the video input
   System.out.println("Unable to open file!");
   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);
   
   // visualization
   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);
   
   //build hsv image
   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);
   }
  }

以下の結果を参照のこと。

image