1
#pragma once
2
#include <opencv2/opencv.hpp>
3
#include <mutex>
4
#include <condition_variable>
5
#include <utility>
6

7
class PingPongFrameBuffer {
8
public:
9
    // 生产者调用：零拷贝指针交换，锁内仅交换头信息
10
    void update(cv::Mat& new_frame) {
11
        if (new_frame.empty()) return;
12

13
        {
14
            std::lock_guard<std::mutex> lock(mutex_);
15
            // std::swap 交换 cv::Mat 头信息和引用计数，耗时仅几纳秒！零内存拷贝！
16
            std::swap(write_buffer_, new_frame);
17
            has_new_frame_ = true;
18
        }
19
        // 通知可能在等待的算法线程
20
        cv_.notify_one();
21
    }
22

23
    // 消费者调用：直接接管最新帧的所有权，耗时同样仅几纳秒
24
    bool getLatest(cv::Mat& out_frame) {
25
        std::unique_lock<std::mutex> lock(mutex_);
26
        // 如果当前没有新帧，最多等待 50 毫秒（避免死锁挂起）
27
        if (!has_new_frame_) {
28
            cv_.wait_for(lock, std::chrono::milliseconds(50), [this] { return has_new_frame_; });
29
        }
30

31
        if (!has_new_frame_) {
32
            return false; // 超时仍未拿到帧
33
        }
34

35
        // 浅拷贝 / 引用传递直接接管这块内存，耗时几纳秒
36
        out_frame = write_buffer_;
37
        has_new_frame_ = false; // 取走后标记为已读
38
        return true;
39
    }
40

41
private:
42
    cv::Mat write_buffer_;
43
    bool has_new_frame_ = false;
44
    std::mutex mutex_;              // 保护指针交换的轻量互斥锁
45
    std::condition_variable cv_;    // 条件变量，避免算法线程空转占满 CPU
46
};

1
#include <opencv2/opencv.hpp>
2
#include <iostream>
3
#include <thread>
4
#include <atomic>
5
#include <chrono>
6

7
#include "PingPongFrameBuffer.hpp"
8
#include "PnPSolver.hpp"
9
#include "TargetDetector.hpp"
10

11
// 控制线程生命周期的原子布尔变量
12
std::atomic<bool> is_running(true);
13

14
// 采图工作线程函数 (生产者)
15
void captureThreadFunc(PingPongFrameBuffer& buffer) {
16
    cv::VideoCapture cap(0);
17
    if (!cap.isOpened()) {
18
        std::cerr << "[采图线程] 无法打开视频源！" << std::endl;
19
        is_running = false;
20
        return;
21
    }
22

23
    // 关键救命配置：强制 Linux V4L2 内核驱动层只保留 1 帧环形缓冲区，彻底根绝硬件积压
24
    cap.set(cv::CAP_PROP_BUFFERSIZE, 1);
25
    // 针对某些 USB 摄像头设置高帧率参数
26
    cap.set(cv::CAP_PROP_FPS, 60);
27

28
    std::cout << "[采图线程] 启动成功，正在高速取流..." << std::endl;
29

30
    cv::Mat raw_frame;
31
    int capture_count = 0;
32
    auto last_time = std::chrono::steady_clock::now();
33

34
    while (is_running) {
35
        cap >> raw_frame;
36
        if (raw_frame.empty()) {
37
            std::this_thread::sleep_for(std::chrono::milliseconds(2));
38
            continue;
39
        }
40

41
        // 零拷贝指针交换存入双缓冲区
42
        buffer.update(raw_frame);
43
        capture_count++;
44

45
        // 每隔 1 秒打印一次采图帧率
46
        auto now = std::chrono::steady_clock::now();
47
        if (std::chrono::duration_cast<std::chrono::seconds>(now - last_time).count() >= 1) {
48
            std::cout << "[采图线程] 当前采集帧率: " << capture_count << " FPS" << std::endl;
49
            capture_count = 0;
50
            last_time = now;
51
        }
52
    }
53

54
    cap.release();
55
    std::cout << "[采图线程] 安全退出。" << std::endl;
56
}
57

58
int main() {
59
    PingPongFrameBuffer frame_buffer;
60

61
    // 启动独立的采图后台线程
62
    std::thread capture_thread(captureThreadFunc, std::ref(frame_buffer));
63

64
    cv::Mat current_frame;
65
    int process_count = 0;
66
    auto last_time = std::chrono::steady_clock::now();
67

68
    std::cout << "[算法主线程] 启动成功，按 ESC 退出。" << std::endl;
69

70
    while (is_running) {
71
        // 1. 从缓冲区取最新的一帧 (纳秒级零拷贝接管所有权)
72
        if (!frame_buffer.getLatest(current_frame)) {
73
            continue;
74
        }
75

76
        // 2. 模拟耗时算法处理 (故意休眠 25ms 模拟复杂图像计算)
77
        std::this_thread::sleep_for(std::chrono::milliseconds(25));
78

79
        // 3. 在画面上标注状态
80
        cv::putText(current_frame, "Real-time Live", cv::Point(30, 40),
81
                    cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 255, 0), 2);
82

83
        cv::imshow("Multi-thread Vision", current_frame);
84
        process_count++;
85

86
        // 统计算法实际执行帧率
87
        auto now = std::chrono::steady_clock::now();
88
        if (std::chrono::duration_cast<std::chrono::seconds>(now - last_time).count() >= 1) {
89
            std::cout << "[算法主线程] 当前处理帧率: " << process_count << " FPS" << std::endl;
90
            process_count = 0;
91
            last_time = now;
92
        }
93

94
        if (cv::waitKey(1) == 27) { // ESC 退出
95
            is_running = false;
96
            break;
97
        }
98
    }
99

100
    // 等待子线程安全结束回收
101
    if (capture_thread.joinable()) {
102
        capture_thread.join();
103
    }
104

105
    cv::destroyAllWindows();
106
    std::cout << "程序完全退出。" << std::endl;
107
    return 0;
108
}