在 C++ 中优化图像缓冲区

问：

我有 3 台（它们的名字是右、左和后）相机，我同步了它们的帧。但是，代码的性能不是那么好，我想得到一些关于如何优化代码的建议。

“优化”可以是任何东西。事实上，我希望对代码中任何可以做得更好的建议。我是这种编程的新手，只是想学习。

代码说明： 有 3 个线程运行一个繁忙的无限循环，读取相机帧。线程运行 CaptureThread 类的 start（） 函数。该行从相机读取一帧。if (camera_.img_buffer->read(frame_))

class CaptureThread
{
public:
    CaptureThread(const Camera& camera) : camera_(camera)
    {
    }

    void start()
    {
        continue_thread_ = true;
        run();
    }

    void stop()
    {
        continue_thread_ = false;
    }

    void attachBufferManager(const std::shared_ptr<BufferManager>& buffer_manager)
    {
        buffer_manager_ = buffer_manager;
    }

private:
    void run()
    {
        while (continue_thread_)
        {
            if (camera_.img_buffer->read(frame_))
            {
                buffer_manager_->syncAndWrite(camera_, frame_);
            }
        }
    }

    cv::Mat frame_;
    bool continue_thread_ = true;
    Camera camera_;
    std::shared_ptr<BufferManager> buffer_manager_;
};

每个 CaptureThread 都使用 attachBufferManager function（） 将自身附加到 BufferManager 的同一实例

BufferManager 通过将这些图像捆绑到 std：：unordered_map 中来同步这些图像

class BufferManager
{
public:
    BufferManager(int buffer_size) : counter_(0), buffer_size_(buffer_size), num_buffers_(3)
    {
    }

    void syncAndWrite(const Camera& camera, const cv::Mat& frame)
    {
        std::unique_lock lock(mtx_);
        counter_++;
        all_img[camera.name] = frame;

        if (counter_ >= num_buffers_)
        {
            if (all_img_buffer_.size() >= buffer_size_)
            {
                all_img_buffer_.pop();
            }
            all_img_buffer_.push(all_img);
            cv_.notify_all();
            counter_ = 0;
        }
        else
        {
            cv_.wait(lock);
        }
    }

    bool read(std::unordered_map<std::string, cv::Mat>& all_img)
    {
        std::lock_guard lock(mtx_);
        if (all_img_buffer_.empty())
        {
            return false;
        }
        all_img = all_img_buffer_.front();
        all_img_buffer_.pop();
        return true;
    }

private:
    std::queue<std::unordered_map<std::string, cv::Mat>> all_img_buffer_;
    std::unordered_map<std::string, cv::Mat> all_img;
    int counter_;
    int num_buffers_;
    std::condition_variable cv_;
    std::mutex mtx_;
    int buffer_size_;
};

CaptureThread 类的无限循环调用其 BufferManager 的 syncAndWrite 函数

    void run()
    {
        while (continue_thread_)
        {
            if (camera_.img_buffer->read(frame_))
            {
                buffer_manager_->syncAndWrite(camera_, frame_);
            }
        }
    }

syncAndWrite（） 将相机帧存储到 unordered_map （key=std：：string， value=cv：：Mat） 中，并阻塞循环，直到 BufferManager 的变量达到 3。counter_

void syncAndWrite(const Camera& camera, const cv::Mat& frame)
    {
        std::unique_lock lock(mtx_);
        counter_++;
        all_img[camera.name] = frame;

        if (counter_ >= num_buffers_)
        {
            if (all_img_buffer_.size() >= buffer_size_)
            {
                all_img_buffer_.pop();
            }
            all_img_buffer_.push(all_img);
            cv_.notify_all();
            counter_ = 0;
        }
        else
        {
            cv_.wait(lock);
        }
    }

camera.name是“right”、“left”或“back”的字符串

稍后，读取并显示 BufferManager 的all_img_buffer

while (true)
    {
        if (buffer_manager->read(all_imgs))
        {
            cv::hconcat(all_imgs["right"], all_imgs["back"], all_frame);
            cv::hconcat(all_frame, all_imgs["left"], all_frame);
            cv::imshow("all_imgs", all_frame);
            if (cv::waitKey(1) == 'q')
            {
                break;
            }
        }
    }

使用 cv：：imshow（） 查看 3 帧会导致感觉像是 ~10fps 的视频，这并不理想。一次查看 1 台摄像机感觉就像 ~30fps。