OPenCV CUDA模块光流------高效地执行光流估计的类BroxOpticalFlow

news2025/6/7 13:41:19

操作系统：ubuntu22.04
OpenCV版本：OpenCV4.9
IDE:Visual Studio Code
编程语言：C++11

算法描述

cv::cuda::BroxOpticalFlow 是 OpenCV CUDA 模块中实现Brox光流算法的类。该类用于在 GPU 上高效地计算两帧图像之间的稠密光流（Dense Optical Flow）。

什么是 Brox 光流？

Brox 光流算法是由 Thomas Brox 等人在 2004 年提出的一种基于变分法的稠密光流估计方法，它结合了：

亮度一致性约束（Brightness Constancy Constraint）
运动平滑性约束（Smoothness Constraint）
梯度一致性约束（Gradient Constancy Constraint）

这个算法在准确性和鲁棒性方面表现良好，尤其适用于小到中等运动的场景。

cv::cuda::BroxOpticalFlow 类概述

属性	描述
头文件	<opencv2/cudaoptflow.hpp>
命名空间	cv::cuda
继承自	cv::cuda::DenseOpticalFlow
用途	计算两个图像帧之间的稠密光流（每个像素都有一个运动向量）
GPU 加速	支持 CUDA GPU 加速

创建与初始化

创建对象

cv::Ptr<cv::cuda::BroxOpticalFlow> brox = cv::cuda::BroxOpticalFlow::create
(
    float alpha,
    float gamma,
    float scale_factor,
    int inner_iterations,
    int outer_iterations,
    int solver_iterations
);

参数说明：

参数名	类型	含义
alpha	float	控制光流平滑程度的正则化参数（越大越平滑）
gamma	float	控制梯度一致性的权重
scale_factor	float	图像金字塔缩放因子（通常为 0.5 表示每层缩小一半）
inner_iterations	int	内部迭代次数（求解线性系统）
outer_iterations	int	外部迭代次数（优化整体光流场）
solver_iterations	int	求解器每次迭代的次数（Jacobi 迭代次数）

使用流程

准备输入图像（必须是灰度图）

cv::Mat frame1_gray, frame2_gray;
cv::cvtColor(frame1, frame1_gray, cv::COLOR_BGR2GRAY);
cv::cvtColor(frame2, frame2_gray, cv::COLOR_BGR2GRAY);

转换为浮点格式并归一化（[0, 1] 区间）

cv::Mat frame1_32f, frame2_32f;
frame1_gray.convertTo(frame1_32f, CV_32F, 1.0 / 255.0);
frame2_gray.convertTo(frame2_32f, CV_32F, 1.0 / 255.0);

上传图像到 GPU

cv::cuda::GpuMat d_frame1, d_frame2;
d_frame1.upload(frame1_32f);
d_frame2.upload(frame2_32f);

初始化 BroxOpticalFlow 对象

cv::Ptr<cv::cuda::BroxOpticalFlow> brox = cv::cuda::BroxOpticalFlow::create(
    0.197f,   // alpha
    50.0f,    // gamma
    0.8f,     // scale_factor
    10,       // inner_iterations
    77,       // outer_iterations
    10        // solver_iterations
);

创建输出矩阵（类型为 CV_32FC2）

cv::cuda::GpuMat d_flow;  // 输出光流，每个像素是一个 (dx, dy) 向量

执行光流计算

brox->calc(d_frame1, d_frame2, d_flow);

分离 flow_x 和 flow_y（可选）

std::vector<cv::cuda::GpuMat> flow_parts(2);
cv::split(d_flow, flow_parts);  // flow_parts[0] = dx, flow_parts[1] = dy

下载结果到 CPU（显示或保存用）

cv::Mat host_flowx, host_flowy;
flow_parts[0].download(host_flowx);
flow_parts[1].download(host_flowy);

代码示例

#include <opencv2/cudaimgproc.hpp>  // for split
#include <opencv2/cudaoptflow.hpp>  // for BroxOpticalFlow
#include <opencv2/opencv.hpp>       // core OpenCV

using namespace cv;
using namespace cv::cuda;

int main()
{
    // Step 1: 加载图像
    std::string path1 = "/media/dingxin/data/study/OpenCV/sources/images/frame1.png";
    std::string path2 = "/media/dingxin/data/study/OpenCV/sources/images/frame2.png";

    Mat frame1 = imread(path1, IMREAD_GRAYSCALE);
    Mat frame2 = imread(path2, IMREAD_GRAYSCALE);

    if (frame1.empty() || frame2.empty())
    {
        std::cerr << "无法加载图像！路径：" << path1 << " 或 " << path2 << std::endl;
        return -1;
    }

    // Step 2: 转换为浮点格式 CV_32FC1 并归一化到 [0,1]
    Mat frame1_32f, frame2_32f;
    frame1.convertTo(frame1_32f, CV_32F, 1.0 / 255.0);
    frame2.convertTo(frame2_32f, CV_32F, 1.0 / 255.0);

    // Step 3: 上传到 GPU
    GpuMat d_frame1, d_frame2;
    d_frame1.upload(frame1_32f);
    d_frame2.upload(frame2_32f);

    // Step 4: 创建 BroxOpticalFlow 对象
    Ptr<BroxOpticalFlow> brox = BroxOpticalFlow::create();

    // Step 5: 创建输出矩阵（CV_32FC2 类型）
    GpuMat d_flow;

    // Step 6: 执行光流计算
    brox->calc(d_frame1, d_frame2, d_flow);

    // Step 7: 下载光流结果到CPU
    Mat host_flow;
    d_flow.download(host_flow);  // 先下载到CPU

    // Step 8: 分离 flow_x 和 flow_y (在CPU上进行)
    std::vector<Mat> flow_parts(2);
    split(host_flow, flow_parts);  // 现在使用的是CPU上的cv::split

    Mat host_flowx = flow_parts[0];
    Mat host_flowy = flow_parts[1];

    // Step 9: 归一化显示
    Mat flowx_show, flowy_show;
    normalize(host_flowx, flowx_show, 0, 1, NORM_MINMAX, CV_32F);
    normalize(host_flowy, flowy_show, 0, 1, NORM_MINMAX, CV_32F);

    imshow("Flow X", flowx_show);
    imshow("Flow Y", flowy_show);

    // Step 10: 合成彩色光流图（HSV 表示方向和强度）
    Mat mag, ang;
    cartToPolar(host_flowx, host_flowy, mag, ang, true);  // 计算 magnitude & angle

    Mat hsv_channels[3];
    hsv_channels[0] = ang;                              // Hue 表示方向
    hsv_channels[1] = Mat::ones(ang.size(), CV_32F);    // Saturation 固定最大
    hsv_channels[2] = mag;                              // Value 表示运动强度

    Mat hsv_merged, bgr_out;
    merge(hsv_channels, 3, hsv_merged);                    // 合并通道
    hsv_merged.convertTo(hsv_merged, CV_8U, 255);          // 转换为 0~255
    cv::cvtColor(hsv_merged, bgr_out, cv::COLOR_HSV2BGR);  // 显式使用 CPU 版本

    imshow("Optical Flow Color Map", bgr_out);

    waitKey(0);  // 等待按键关闭窗口
    return 0;
}