上節說到過的calcOpticalFlowPyrLK光流演算法，可以看到它實際上是一種稀疏特徵點的光流演算法，也就是說我們先找到那些（特徵）點需要進行處理，然後再處理，該節介紹下一個全域性性的密集光流演算法，也就是對每一個點都進行光流計算，函式為calcOpticalFlowFarneback。

引數一大推，得看一會。有些引數可能帶來的影響不是很大，那麼使用它推薦的引數即可。完整的引數達10個。按順序：

prevImg：輸入第一個圖
nextImg：輸入第二個圖
Flow：輸出的光流矩陣。矩陣大小同輸入的影象一樣大，但是矩陣中的每一個元素可不是一個值，而是兩個值，分別表示這個點在x方向與y方向的運動量（偏移量）。所以要把這個光流場矩陣顯示出來還真的需要費點力。那麼上面說的兩幅影象與這個光流場是什麼關係呢？如下：

pyrScale：一個構造影象金字塔的引數，一般就認為是0.5最好了，也就是將影象縮小一半。那麼為什麼要構造金字塔呢？這應該是與演算法本身的設計有關，其實很多地方在檢測特徵的時候都會涉及到影象的金字塔，設想下如果有個特徵點在原始尺寸與其縮小的尺寸下都是特徵點的話，那麼這個特徵點就很有效了吧。
Levels：依然是與金字塔有關引數，常設值1.
Winsize：相當於一個均值濾波的作用，視窗大小決定了其噪聲的抑制能力什麼的。
Iterations：在每層金字塔上的迭代次數。
polyN：點與附近領域點之間的聯絡作用，一般為5,7等等即可。
polySigma ：畫素點的一個平滑水平，一般1-1.5即可。
Flags：一個標記，決定計算方法。

具體怎麼影響結果的，可以自己去嘗試。
下面對上節使用到的兩幅圖，通過這個方法來計算這兩幀影象中存在的光流場，也就是把上述的Flow找出來，那些引數也決定了Flow找出來的不一樣。簡單的程式如下：

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/video/video.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/types_c.h>
 

#include <iostream>
#include <cstdio>

using namespace std;
using namespace cv;
#define UNKNOWN_FLOW_THRESH 1e9  

void makecolorwheel(vector<Scalar> &colorwheel)  
{  
    int RY = 15;  
    int YG = 6;  
    int GC = 4;  
    int CB = 11;  
    int BM = 13;  
    int MR = 6;  

    int i;  

    for (i = 0; i < RY; i++) colorwheel.push_back(Scalar(255,       255*i/RY,     0));  
    for (i = 0; i < YG; i++) colorwheel.push_back(Scalar(255-255*i/YG, 255,       0));  
    for (i = 0; i < GC; i++) colorwheel.push_back(Scalar(0,         255,      255*i/GC));  
    for (i = 0; i < CB; i++) colorwheel.push_back(Scalar(0,         255-255*i/CB, 255));  
    for (i = 0; i < BM; i++) colorwheel.push_back(Scalar(255*i/BM,      0,        255));  
    for (i = 0; i < MR; i++) colorwheel.push_back(Scalar(255,       0,        255-255*i/MR));  
}  

void motionToColor(Mat flow, Mat &color)  
{  
    if (color.empty())  
        color.create(flow.rows, flow.cols, CV_8UC3);  

    static vector<Scalar> colorwheel; //Scalar r,g,b  
    if (colorwheel.empty())  
        makecolorwheel(colorwheel);  

    // determine motion range:  
    float maxrad = -1;  

    // Find max flow to normalize fx and fy  
    for (int i= 0; i < flow.rows; ++i)   
    {  
        for (int j = 0; j < flow.cols; ++j)   
        {  
            Vec2f flow_at_point = flow.at<Vec2f>(i, j);  
            float fx = flow_at_point[0];  
            float fy = flow_at_point[1];  
            if ((fabs(fx) >  UNKNOWN_FLOW_THRESH) || (fabs(fy) >  UNKNOWN_FLOW_THRESH))  
                continue;  
            float rad = sqrt(fx * fx + fy * fy);  
            maxrad = maxrad > rad ? maxrad : rad;  
        }  
    }  

    for (int i= 0; i < flow.rows; ++i)   
    {  
        for (int j = 0; j < flow.cols; ++j)   
        {  
            uchar *data = color.data + color.step[0] * i + color.step[1] * j;  
            Vec2f flow_at_point = flow.at<Vec2f>(i, j);  

            float fx = flow_at_point[0] / maxrad;  
            float fy = flow_at_point[1] / maxrad;  
            if ((fabs(fx) >  UNKNOWN_FLOW_THRESH) || (fabs(fy) >  UNKNOWN_FLOW_THRESH))  
            {  
                data[0] = data[1] = data[2] = 0;  
                continue;  
            }  
            float rad = sqrt(fx * fx + fy * fy);  

            float angle = atan2(-fy, -fx) / CV_PI;  
            float fk = (angle + 1.0) / 2.0 * (colorwheel.size()-1);  
            int k0 = (int)fk;  
            int k1 = (k0 + 1) % colorwheel.size();  
            float f = fk - k0;  
            //f = 0; // uncomment to see original color wheel  

            for (int b = 0; b < 3; b++)   
            {  
                float col0 = colorwheel[k0][b] / 255.0;  
                float col1 = colorwheel[k1][b] / 255.0;  
                float col = (1 - f) * col0 + f * col1;  
                if (rad <= 1)  
                    col = 1 - rad * (1 - col); // increase saturation with radius  
                else  
                    col *= .75; // out of range  
                data[2 - b] = (int)(255.0 * col);  
            }  
        }  
    }  
}  


int main()
{
    Mat I1;
    Mat I2;
    Mat flow;
    //讀取兩個影象---相鄰幀
    I1 = imread("I1.jpg",0);//讀取為灰度影象
    I2 = imread("I2.jpg",0);
    calcOpticalFlowFarneback(I1,I2,flow,0.5,3,20,3,5,1.2,0);
    //cout<<I1.size()<<flow.size()<<flow.at<Vec2f>(10,10)<<endl;
    //flow = abs(flow);
    Mat motion2color;  
    motionToColor(flow, motion2color);  
    imshow("flow",motion2color);
    waitKey(0);
    return 0;
}

可以看到程式的大部分是在如何把計算的光流flow可視化出來，雖然我們已經知道它是一個矩陣，而且矩陣中每個元素都包括2個值。但是顯示出來也比較費勁，顯示的函式是參考部落格：

該部落格裡面的內容也是值得一看的。
那麼我們這裡的一個結果如下（原始圖見上篇）：

顏色越深表示該部分存在的運動變化越大。

早點版本（3.0之前）的opencv中還有好幾個光流計算函式，什麼塊匹配BM法，HS法，LK法等等，每一種方法幾乎都對應一篇相關文章而來。後幾種方法的結果無非也都是計算出光流場（在x方向的光流與在y方向的光流）。3.0的opencv似乎把塊匹配、HS等方法捨棄了？沒有找到，想使用那些方法的恐怕還要使用以前的opencv版本才行。