基于卡尔曼滤波的背景建模与车辆检测(OpenCV实现)

简介: OpenCV程序,使用卡尔曼滤波进行背景建模,然后通过差分法进行车辆检测。该程序包含详细的注释和优化处理。

OpenCV程序,使用卡尔曼滤波进行背景建模,然后通过差分法进行车辆检测。该程序包含详细的注释和优化处理。

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <cmath>

using namespace cv;
using namespace std;

class KalmanBackgroundModel {
   
private:
    KalmanFilter KF;       // 卡尔曼滤波器实例
    Mat state;             // 状态向量 [x, y, vx, vy]^T
    Mat measurement;       // 测量向量 [x, y]^T
    float learning_rate;   // 背景学习率
    Size frame_size;       // 帧尺寸
    Mat background;        // 背景模型
    bool initialized;      // 是否已初始化

public:
    KalmanBackgroundModel(Size size, float rate = 0.05) 
        : frame_size(size), learning_rate(rate), initialized(false) {
   

        // 初始化卡尔曼滤波器 (状态维度4,测量维度2)
        KF.init(4, 2, 0);

        // 状态转移矩阵 (匀速模型)
        KF.transitionMatrix = (Mat_<float>(4, 4) << 
            1, 0, 1, 0,
            0, 1, 0, 1,
            0, 0, 1, 0,
            0, 0, 0, 1);

        // 测量矩阵 (只能测量位置)
        KF.measurementMatrix = (Mat_<float>(2, 4) << 
            1, 0, 0, 0,
            0, 1, 0, 0);

        // 过程噪声协方差
        setIdentity(KF.processNoiseCov, Scalar::all(1e-4));

        // 测量噪声协方差
        setIdentity(KF.measurementNoiseCov, Scalar::all(1e-1));

        // 后验误差协方差
        setIdentity(KF.errorCovPost, Scalar::all(1));

        // 初始化状态和测量向量
        state = Mat::zeros(4, 1, CV_32F);
        measurement = Mat::zeros(2, 1, CV_32F);

        // 初始化背景模型
        background = Mat::zeros(size, CV_8UC3);
    }

    void update(const Mat& frame, const Rect& roi) {
   
        if (!initialized) {
   
            // 使用ROI区域初始化背景模型
            Mat roi_bg = background(roi);
            frame(roi).copyTo(roi_bg);
            initialized = true;
            return;
        }

        // 获取当前帧的ROI区域
        Mat current_roi = frame(roi);
        Mat bg_roi = background(roi);

        // 计算当前帧与背景的差异
        Mat diff;
        absdiff(current_roi, bg_roi, diff);

        // 转换为灰度图并计算差异强度
        Mat gray_diff;
        cvtColor(diff, gray_diff, COLOR_BGR2GRAY);
        Scalar mean_diff = mean(gray_diff);

        // 如果差异小于阈值,更新背景模型
        if (mean_diff[0] < 30) {
   
            // 加权平均更新背景
            addWeighted(bg_roi, 1 - learning_rate, current_roi, learning_rate, 0, bg_roi);
        }
    }

    Mat getBackground() const {
   
        return background.clone();
    }

    void applyKalmanFilter(Point2f measurement_point) {
   
        // 设置测量值
        measurement.at<float>(0) = measurement_point.x;
        measurement.at<float>(1) = measurement_point.y;

        // 卡尔曼预测
        Mat prediction = KF.predict();

        // 卡尔曼更新
        KF.correct(measurement);

        // 返回更新后的状态
        state = KF.statePre.clone();
    }

    Point2f getPredictedPosition() const {
   
        return Point2f(state.at<float>(0), state.at<float>(1));
    }
};

void detectVehicles(const Mat& frame, Mat& foreground, double threshold = 30.0) {
   
    Mat gray;
    cvtColor(frame, gray, COLOR_BGR2GRAY);
    GaussianBlur(gray, gray, Size(5, 5), 0);

    // 计算帧间差分
    static Mat prev_frame;
    if (prev_frame.empty()) {
   
        prev_frame = gray.clone();
        foreground = Mat::zeros(frame.size(), CV_8UC1);
        return;
    }

    Mat diff1, diff2;
    absdiff(gray, prev_frame, diff1);
    prev_frame = gray.clone();

    // 二值化处理
    threshold(diff1, foreground, threshold, 255, THRESH_BINARY);

    // 形态学操作去除噪声
    Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(5, 5));
    morphologyEx(foreground, foreground, MORPH_OPEN, kernel);
    morphologyEx(foreground, foreground, MORPH_CLOSE, kernel);
}

vector<Rect> extractVehicleRegions(const Mat& foreground, double min_area = 500.0) {
   
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    findContours(foreground, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

    vector<Rect> vehicles;
    for (const auto& contour : contours) {
   
        double area = contourArea(contour);
        if (area > min_area) {
   
            Rect bbox = boundingRect(contour);
            vehicles.push_back(bbox);
        }
    }
    return vehicles;
}

void visualizeResults(Mat& frame, const Mat& foreground, const vector<Rect>& vehicles) {
   
    // 显示前景掩码
    Mat fg_display;
    cvtColor(foreground, fg_display, COLOR_GRAY2BGR);
    addWeighted(frame, 0.7, fg_display, 0.3, 0, frame);

    // 绘制检测到的车辆
    for (const auto& vehicle : vehicles) {
   
        rectangle(frame, vehicle, Scalar(0, 255, 0), 2);
        putText(frame, "Vehicle", Point(vehicle.x, vehicle.y - 5), 
                FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 2);
    }

    // 显示车辆数量
    string count_text = format("Vehicles: %d", (int)vehicles.size());
    putText(frame, count_text, Point(10, 30), FONT_HERSHEY_SIMPLEX, 1, Scalar(0, 0, 255), 2);
}

int main(int argc, char** argv) {
   
    // 打开视频文件或摄像头
    VideoCapture cap;
    if (argc > 1) {
   
        cap.open(argv[1]);
    } else {
   
        cap.open(0); // 默认摄像头
    }

    if (!cap.isOpened()) {
   
        cerr << "Error opening video source" << endl;
        return -1;
    }

    // 获取视频帧尺寸
    Size frame_size(static_cast<int>(cap.get(CAP_PROP_FRAME_WIDTH)),
                   static_cast<int>(cap.get(CAP_PROP_FRAME_HEIGHT)));

    // 创建背景模型
    KalmanBackgroundModel bg_model(frame_size, 0.03);

    // 创建显示窗口
    namedWindow("Vehicle Detection", WINDOW_NORMAL);
    resizeWindow("Vehicle Detection", 1280, 720);

    Mat frame, foreground, background;
    vector<Rect> vehicles;
    int frame_count = 0;

    while (true) {
   
        cap >> frame;
        if (frame.empty()) break;

        frame_count++;

        // 每10帧更新一次背景模型
        if (frame_count % 10 == 0) {
   
            // 随机选择ROI区域更新背景
            Point pt(rand() % (frame.cols - 100), rand() % (frame.rows - 100));
            Rect roi(pt, Size(100, 100));
            bg_model.update(frame, roi);
            background = bg_model.getBackground();
        }

        // 检测运动目标
        detectVehicles(frame, foreground, 30.0);

        // 提取车辆区域
        vehicles = extractVehicleRegions(foreground, 800.0);

        // 应用卡尔曼滤波预测车辆位置
        for (auto& vehicle : vehicles) {
   
            Point2f center(vehicle.x + vehicle.width/2.0f, 
                          vehicle.y + vehicle.height/2.0f);
            bg_model.applyKalmanFilter(center);

            // 获取预测位置并绘制
            Point2f pred = bg_model.getPredictedPosition();
            circle(frame, pred, 10, Scalar(0, 0, 255), 2);
        }

        // 可视化结果
        visualizeResults(frame, foreground, vehicles);

        // 显示结果
        imshow("Vehicle Detection", frame);

        // 显示背景模型
        if (!background.empty()) {
   
            imshow("Background Model", background);
        }

        // 退出键
        if (waitKey(30) == 27) break;
    }

    cap.release();
    destroyAllWindows();
    return 0;
}

算法原理详解

1. 卡尔曼滤波背景建模

卡尔曼滤波用于建立动态背景模型,其核心思想是:

  • 将每个像素的运动视为一个动态系统

  • 使用状态方程描述像素值的变化

  • 通过预测-更新循环不断优化背景估计

状态向量:$x=[x,y,v_x,v_y]^T$

  • $(x,y)$:像素位置

  • $(v_x,v_y)$:像素运动速度

状态转移方程:
image.png

其中wk是过程噪声。

2. 背景差分法

  1. 帧间差分:计算连续两帧之间的差异
    image.png
  1. 二值化:将差异图像转换为二值图像
    image.png
  1. 形态学处理:去除噪声和小区域

  2. 连通区域分析:提取运动目标

3. 车辆检测优化

  1. 自适应背景更新:

    • 仅当区域稳定时更新背景

    • 使用加权平均避免突变

    $B_{t+1}=(1−α)B_t+αI_t$

  2. 运动预测:

    • 使用卡尔曼滤波预测车辆位置

    • 减少因检测延迟导致的目标丢失

  3. 多特征融合:

    • 结合运动信息和形状特征

    • 使用面积和长宽比过滤误检

参数说明

参数 推荐值 作用
learning_rate 0.01-0.1 背景更新速度
threshold 20-50 运动检测灵敏度
min_area 500-2000 最小车辆面积
形态学核大小 3×3 到 7×7 噪声去除程度
卡尔曼Q/R 0.001-0.1 滤波平滑度

参考代码 采用卡尔曼滤波进行背景建模再作差分的方法的车辆检测程序(OPENCV) www.youwenfan.com/contentali/122412.html

扩展功能

  1. 车辆跟踪:

    class VehicleTracker {
         
    public:
        void update(const Rect& detection);
        Rect predict();
        vector<Point> getTrajectory() const;
    private:
        deque<Point> trajectory;
        KalmanFilter KF;
    };
    
  2. 速度估计:

    // 根据帧率和位移计算速度
    double calculateSpeed(const Point& prev, const Point& curr) {
         
        double pixels_per_meter = 10.0; // 校准参数
        double displacement = norm(curr - prev);
        return (displacement / pixels_per_meter) * fps * 3.6; // km/h
    }
    
  3. 分类器集成:

    // 使用预训练的深度学习模型进行分类
    Net net = readNetFromTensorflow("frozen_inference_graph.pb");
    Mat blob = blobFromImage(frame, 1.0, Size(300, 300), Scalar(), true);
    net.setInput(blob);
    Mat detections = net.forward();
    
  4. 车道线检测:

    // 结合车道线检测提高检测精度
    vector<Vec4i> detectLanes(const Mat& frame) {
         
        // 霍夫变换检测直线
        // 拟合车道线方程
    }
    

实际部署注意事项

  1. 光照变化处理:

    • 使用自适应阈值

    • 添加光照归一化步骤

    cvtColor(frame, lab, COLOR_BGR2Lab);
    vector<Mat> lab_planes;
    split(lab, lab_planes);
    equalizeHist(lab_planes[0], lab_planes[0]);
    merge(lab_planes, lab);
    cvtColor(lab, normalized, COLOR_Lab2BGR);
    
  2. 阴影抑制:

    // 使用HSV颜色空间分离阴影
    Mat hsv;
    cvtColor(frame, hsv, COLOR_BGR2HSV);
    // 阴影区域具有相似的色调和较低的饱和度/明度
    
  3. 夜间处理:

    // 夜间模式增强
    if (isNightScene(frame)) {
         
        // 使用红外图像或增强对比度
        Ptr<CLAHE> clahe = createCLAHE(3.0, Size(8, 8));
        clahe->apply(gray, enhanced);
    }
    
  4. 多摄像头融合:

    // 融合多个视角的检测结果
    vector<Rect> fusedDetections;
    for (const auto& cam : cameras) {
         
        auto dets = cam.getDetections();
        fusedDetections.insert(fusedDetections.end(), dets.begin(), dets.end());
    }
    // 使用匈牙利算法进行数据关联
    

编译与运行

  1. 安装依赖:

    sudo apt-get install libopencv-dev
    
  2. 编译程序:

    g++ -std=c++11 vehicle_detection.cpp -o vehicle_detection \
         `pkg-config --cflags --libs opencv4`
    
  3. 运行程序:

    ./vehicle_detection [video_file.mp4]  # 使用视频文件
    ./vehicle_detection                  # 使用摄像头
    

结果可视化

程序提供四个可视化窗口:

  1. Vehicle Detection:主检测窗口,显示车辆边界框和预测位置

  2. Background Model:当前背景模型

  3. 前景掩码:二值化的运动检测结果

  4. 车辆轨迹:车辆运动轨迹(需扩展实现)

程序还显示实时车辆计数和位置信息,便于监控系统集成。

注意:实际应用中,建议使用OpenCV的DNN模块集成深度学习模型(如YOLO、SSD)以提高检测精度和鲁棒性。本实现展示了传统计算机视觉方法的核心原理,可作为更复杂系统的基础。

相关文章
|
5月前
|
机器学习/深度学习 监控 安全
人脸表情七种表情数据集分享(适用于YOLO系列深度学习分类检测任务)
本数据集含15,500张高质量人脸图像,覆盖惊讶、恐惧、厌恶、高兴、悲伤、愤怒、中性七类表情,已按YOLO格式划分训练集(12,000张)与测试集(3,500张),标注精准、类别均衡,开箱即用于分类/检测任务。
583 0
|
7月前
|
算法 数据挖掘 语音技术
基于隐马尔可夫模型(HMM)的语音识别实现
基于隐马尔可夫模型(HMM)的语音识别实现,结合MATLAB平台,涵盖语音预处理、特征提取、模型训练与识别全流程
|
6月前
|
数据采集 存储 自动驾驶
数据治理是什么?数据治理与数据要素、数据资源、数据资产、数据管理的区别
本文厘清“数据要素、资源、资产、管理、治理”五大易混淆概念:要素是国家层面的新型生产要素;资源是原始数据集合;资产是确权入表的价值形态;管理是全生命周期执行;治理是顶层设计与权责体系。五者层层递进,构成数据价值闭环。
|
6月前
|
人工智能 算法 安全
2026全球Geo优化行业方法论深度评分报告白皮书
报告重点聚焦于Geo专家于磊首创的“两大核心+四轮驱动”体系,并将其与学术界及工业界的其他主流路径进行对比,为企业提供权威的决策参考。
371 5
|
6月前
|
人工智能 自然语言处理 安全
阿里云百炼Token Plan(团队版)怎么样?为企业解决了哪些AI订阅痛点?功能、优势与适用场景解析
阿里云百炼Token Plan(团队版)是面向企业团队推出的AI大模型订阅服务,以Credits统一计量,支持Qwen、GLM、Kimi等20+主流模型灵活切换,兼容Qoder、OpenClaw等主流AI编程与智能体工具。提供标准、高级、尊享三档坐席套餐及共享用量包,包月预算可控。内置团队管理后台,支持席位分配、用量分析与权限控制;通过统一接入解决企业多平台分散管理、成本不透明、安全失控等痛点,适合规模化AI开发与跨部门协作场景。
|
7月前
|
监控 供应链 BI
Quick BI使用案例19:交叉表中当日订单金额百分位与基于嵌套计算的订单金额日环比百分位的双重分析
本文详解生鲜电商如何用“订单金额按列百分位”以及“基于嵌套计算的订单金额日环比百分位”的双重分析实现区域需求实时监控:连续2天百分位超80%为“爆发区”自动补货,连续2天百分位低于10%为“冰冻区”智能调拨,降低损耗、提升现货率。
|
5月前
|
存储 编解码 算法
MAX6675 K型热电偶温度采集程序(Keil环境)
MAX6675 K型热电偶温度采集程序(Keil环境)
|
5月前
|
存储 程序员 调度
程序员必备的十大技能(进阶版)之底层计算机原理(一)
教程来源 http://zlpow.cn/ 本文深入计算机底层原理,涵盖体系结构、CPU微架构、内存层次、I/O、操作系统、汇编、编译链接等十大维度,揭示代码如何在硬件上高效运行,助开发者写出更可靠、高性能的程序。
|
5月前
|
数据采集 JSON API
Python爬虫实战:多协议适配的图书网站多源数据采集方案
Python爬虫实战:多协议适配的图书网站多源数据采集方案
|
5月前
|
运维 监控 算法
城市环境下车辆目标跟踪算法 MATLAB 实现
城市环境下车辆目标跟踪算法 MATLAB 实现
220 1