opencv支持的一些计算光流的算法

1. Lucas-Kanade（LK）光流算法
   Lucas-Kanade（LK）光流算法是一种经典的稀疏光流算法，用于估计图像中局部区域的运动信息。它最初由Bruce D. Lucas和Takeo Kanade于1981年提出，是最早的光流估计方法之一，至今仍然被广泛应用。
   LK光流算法的基本原理是利用局部区域的像素灰度值在两帧图像中的变化来估计运动向量。具体而言，它假设了一个关于运动的线性模型，并通过最小化每个像素周围邻域的灰度值误差来求解最佳的运动向量。

算法步骤如下：

选择特征点：首先，在图像中选择一组关键的特征点或角点，通常使用角点检测算法（如Harris角点检测）来检测这些特征点。

建立窗口：对于每个选定的特征点，定义一个小的局部窗口，通常是一个矩形区域，用来捕获周围像素的灰度信息。

计算灰度梯度：在每个窗口中，计算每个像素位置处的灰度梯度，通常使用Sobel算子或其他梯度计算方法。

构建雅可比矩阵：根据当前帧和下一帧图像的灰度梯度信息，构建一个关于运动参数的雅可比矩阵，这个矩阵描述了像素灰度值对运动参数的响应。

求解运动向量：通过最小化当前帧窗口中像素灰度值与下一帧窗口中对应位置像素灰度值之间的误差（通常使用最小二乘法），来求解最佳的运动向量。

迭代优化：通常，LK算法会进行多次迭代来不断优化运动向量的估计值，直到达到收敛条件或达到最大迭代次数。

输出光流场：最终，对于每个特征点，得到其对应的运动向量，从而形成整个图像的光流场。

总的来说，Lucas-Kanade光流算法是一种经典的稀疏光流算法，适用于处理运动相对较小且区域局部性较强的图像序列，如视觉里程计、目标跟踪等任务。

import cv2

# 读取视频
cap = cv2.VideoCapture('video.mp4')

# 创建LK光流对象
lk_flow = cv2.optflow.createOptFlow_DeepFlow()

# 读取第一帧
ret, prev_frame = cap.read()

# 转换为灰度图像
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)

# 设置角点检测参数
feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7)

# 获取第一帧的角点
prev_pts = cv2.goodFeaturesToTrack(prev_gray, mask=None, **feature_params)

# 创建掩码用于绘制轨迹
mask = np.zeros_like(prev_frame)

# 循环处理每一帧
while True:
    # 读取当前帧
    ret, frame = cap.read()
    if not ret:
        break
    
    # 转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 计算LK光流
    next_pts, status, _ = cv2.calcOpticalFlowPyrLK(prev_gray, gray, prev_pts, None)
    
    # 选择好的点
    good_next_pts = next_pts[status == 1]
    good_prev_pts = prev_pts[status == 1]
    
    # 绘制轨迹
    for i, (new, old) in enumerate(zip(good_next_pts, good_prev_pts)):
        a, b = new.ravel()
        c, d = old.ravel()
        mask = cv2.line(mask, (a, b), (c, d), (0, 255, 0), 2)
        frame = cv2.circle(frame, (a, b), 5, (0, 0, 255), -1)
    
    # 合并光流图像和原始图像
    img = cv2.add(frame, mask)
    
    # 更新前一帧的图像和角点
    prev_gray = gray.copy()
    prev_pts = good_next_pts.reshape(-1, 1, 2)
    
    # 显示结果
    cv2.imshow('Optical Flow', img)
    
    # 按 'q' 键退出循环
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

示例代码中，首先检测第一帧中的角点，然后利用LK光流算法跟踪这些角点的运动，并绘制出轨迹。最后，将轨迹绘制到原始图像上并显示。

2. Farneback光流算法
   Farneback光流算法是一种基于密集光流的方法，用于估计图像序列中每个像素的运动。它由Gunnar Farneback于2003年提出，并在后续的研究中得到改进和拓展。

Farneback算法的主要思想是利用多项式展开来近似描述图像中每个像素周围的运动。具体来说，它通过对图像中局部区域进行多项式拟合来估计每个像素的运动速度和方向。

算法步骤如下：

图像金字塔构建：首先，对输入的图像序列构建高斯金字塔，这样可以处理不同尺度的运动，并使得算法对于不同尺度的运动都有较好的适应性。

密集光流计算：在每个金字塔层级上，对图像进行光流计算。Farneback算法通过计算相邻图像块之间的像素强度差异，来估计局部运动的相似性。

多项式展开：对于每个像素，使用多项式展开来逼近其周围像素的运动。这种多项式展开考虑了多个尺度上的运动信息，并能够更准确地描述局部运动的复杂性。

运动向量估计：根据多项式展开得到的参数，估计每个像素的运动速度和方向。这些参数反映了图像中每个像素的局部运动情况。

光流场重建：将每个像素的运动信息整合起来，形成完整的光流场。这个光流场描述了图像序列中每个像素的运动情况，可以用于后续的运动分析和处理任务。

总的来说，Farneback光流算法是一种基于密集光流的方法，适用于需要精细的像素级别运动信息的任务，如视频稳定、光流场估计等。它能够有效地处理图像中的复杂运动。

import cv2

# 读取视频
cap = cv2.VideoCapture('video.mp4')

# 创建Farneback光流对象
farneback_flow = cv2.optflow.createOptFlow_Farneback()

# 创建LK光流对象
lk_flow = cv2.optflow.createOptFlow_DeepFlow()

# 读取第一帧
ret, prev_frame = cap.read()

# 转换为灰度图像
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)

# 循环处理每一帧
while True:
    # 读取当前帧
    ret, frame = cap.read()
    if not ret:
        break
    
    # 转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 计算Farneback光流
    flow_farneback = farneback_flow.calc(prev_gray, gray, None)
    
    # 计算LK光流
    flow_lk = lk_flow.calc(prev_gray, gray, None)
    
    # 可视化光流
    # 这里可以根据具体需求进行可视化处理，比如画箭头表示光流方向等
    
    # 更新上一帧
    prev_gray = gray

    # 显示结果
    cv2.imshow('Farneback Optical Flow', frame)
    cv2.imshow('LK Optical Flow', frame)
    
    # 按 'q' 键退出循环
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

3. ROLF光流
   RLOF（Robust Local Optical Flow）算法是一种用于计算光流（optical flow）的局部方法，旨在提高在复杂场景中的光流估计的准确性和鲁棒性。与传统的光流算法相比，RLOF算法采用了一种自适应的局部窗口策略，并且结合了稀疏和密集光流的优点。

RLOF算法的主要特点和原理包括：

自适应局部窗口：RLOF算法采用了一种自适应的局部窗口策略，可以根据图像中的像素运动情况和图像特性来动态调整窗口大小。这种自适应的窗口大小可以帮助提高在不同区域的光流估计精度，并且能够有效地处理非刚体运动和快速动态场景。

鲁棒性：RLOF算法使用了一些鲁棒的技术来提高光流估计的稳健性，如利用局部梯度信息来对光流进行加权，以减少对噪声和异常值的敏感性。

多尺度处理：为了适应不同尺度下的运动情况，RLOF算法通常会对图像进行多尺度处理，以提高光流估计的准确性和鲁棒性。

快速计算：尽管RLOF算法在提高光流估计的准确性和鲁棒性方面进行了改进，但也注重了算法的计算效率，以便在实际应用中能够实时处理图像序列。

RLOF算法在复杂场景中的光流估计任务中表现出了较好的性能，并且在实际应用中得到了广泛的应用。它在视频处理、目标跟踪、动作识别等领域都具有重要的作用。

import cv2

# 读取视频
cap = cv2.VideoCapture('video.mp4')

# 创建稠密光流对象
dense_flow = cv2.optflow.createOptFlow_DenseRLOF()

# 读取第一帧
ret, prev_frame = cap.read()

# 转换为灰度图像
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)

# 循环处理每一帧
while True:
    # 读取当前帧
    ret, frame = cap.read()
    if not ret:
        break
    
    # 转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 计算光流
    flow = dense_flow.calc(prev_gray, gray, None)
    
    # 可视化光流
    # 这里可以根据具体需求进行可视化处理，比如画箭头表示光流方向等
    
    # 更新上一帧
    prev_gray = gray

    # 显示结果
    cv2.imshow('Optical Flow', frame)
    
    # 按 'q' 键退出循环
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

4. DIS光流
   DIS（Dense Inverse Search）光流算法是一种稠密光流算法，与稀疏光流算法（如Lucas-Kanade）不同，它可以计算图像中每个像素的运动向量，而不仅仅是一些选定的特征点。这使得它更适合于一些需要更精细运动信息的任务，比如视频处理、运动分析等。其主要特点包括采用逆向搜索策略、密集采样、多尺度处理和鲁棒性技术。通过逆向搜索，在当前图像中直接搜索与参考图像中对应区域最相似的像素，以确定其光流，从而提高了计算效率。

import cv2

# 读取视频
cap = cv2.VideoCapture('video.mp4')

# 创建DIS光流对象
dis_flow = cv2.optflow.createOptFlow_DIS(cv2.optflow.DISOPTICAL_FLOW_PRESET_MEDIUM)

# 读取第一帧
ret, prev_frame = cap.read()

# 转换为灰度图像
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)

# 循环处理每一帧
while True:
    # 读取当前帧
    ret, frame = cap.read()
    if not ret:
        break
    
    # 转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 计算DIS光流
    flow = dis_flow.calc(prev_gray, gray, None)
    
    # 可视化光流
    # 可以根据需要对光流进行可视化处理，例如绘制箭头表示运动方向等
    
    # 更新前一帧的灰度图像
    prev_gray = gray

    # 显示结果
    cv2.imshow('DIS Optical Flow', frame)
    
    # 按 'q' 键退出循环
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44