C++与OpenCV实现区域入侵监控系统

SmartMonitor/
├── CMakeLists.txt
├── config/monitor.yaml            # 全部运行参数
├── src/
│   ├── main.cpp                   # 程序入口与模块调度
│   ├── config/AppConfig.*         # YAML 配置读取与校验
│   ├── detection/MotionDetector.* # 运动目标检测
│   ├── intrusion/IntrusionDetector.* # 入侵判断与状态机
│   ├── storage/RecordingManager.* # 截图、录像、日志
│   └── utils/TimeUtils.*          # 时间工具
└── output/                        # 运行产物（自动生成）
    ├── screenshots/
    ├── recordings/
    └── events.csv

MotionDetector detector(config);            // 拷贝检测参数
IntrusionDetector intrusionDetector(config);// 拷贝警戒区参数
RecordingManager recordingManager(config);  // 拷贝输出目录参数

bool AppConfig::load(const std::string &configPath)
{
    cv::FileStorage file(configPath, cv::FileStorage::READ);
    if (!file.isOpened())
    {
        std::cerr << "无法打开配置文件: " << configPath << std::endl;
        return false;
    }

    file["source_type"] >> sourceType;
    file["video_path"] >> videoPath;
    file["blur_kernel_size"] >> blurKernelSize;
    // ……其余参数同理
    file.release();

    return validate();
}

if (blurKernelSize <= 0 || blurKernelSize % 2 == 0)
{
    std::cerr << "配置错误: blur_kernel_size 必须是大于 0 的奇数" << std::endl;
    return false;
}
if (diffThreshold < 0 || diffThreshold > 255)
{
    std::cerr << "配置错误: diff_threshold 必须在 0 到 255 之间" << std::endl;
    return false;
}
if (minOverlapRatio <= 0.0 || minOverlapRatio > 1.0)
{
    std::cerr << "配置错误: min_overlap_ratio 必须在 0 到 1 之间" << std::endl;
    return false;
}

vector<Rect> MotionDetector::detect(const Mat &frame, Mat *motionMask)
{
    vector<Rect> targets;
    if (frame.empty())
    {
        return targets;
    }

    // ① 灰度化 + 高斯滤波：丢弃颜色信息，压掉细小噪声
    Mat currentGrayFrame;
    cvtColor(frame, currentGrayFrame, COLOR_BGR2GRAY);
    GaussianBlur(currentGrayFrame, currentGrayFrame,
                 Size(blurKernelSize_, blurKernelSize_), 0);

    // ② 第一次调用没有上一帧，只保存当前帧，不产生结果
    if (previousGrayFrame_.empty())
    {
        previousGrayFrame_ = currentGrayFrame.clone();
        if (motionMask != nullptr)
        {
            *motionMask = Mat::zeros(frame.size(), CV_8UC1);
        }
        return targets;
    }

    // ③ 帧差：当前帧与上一帧逐像素相减，静止部分差值为 0
    Mat differenceFrame, thresholdFrame;
    absdiff(currentGrayFrame, previousGrayFrame_, differenceFrame);
    // ④ 二值化：差异超过阈值的像素置 255（白），其余置 0（黑）
    threshold(differenceFrame, thresholdFrame,
              diffThreshold_, 255, THRESH_BINARY);

    // ⑤ 闭运算：先膨胀再腐蚀，连接邻近的白色碎片、填补内部空洞
    const Mat kernel = getStructuringElement(
        MORPH_RECT, Size(morphKernelSize_, morphKernelSize_));
    morphologyEx(thresholdFrame, thresholdFrame, MORPH_CLOSE, kernel);

    // ⑥ 提取轮廓，过滤面积过小的噪声
    vector<vector<Point>> contours;
    findContours(thresholdFrame, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
    for (const auto &contour : contours)
    {
        if (contourArea(contour) < minObjectArea_)
        {
            continue;
        }
        targets.push_back(boundingRect(contour)); // 用外接矩形代表目标
    }

    // ⑦ 保存当前灰度帧，供下一次比较
    previousGrayFrame_ = currentGrayFrame.clone();
    return targets;
}

imshow("frame", displayFrame);      // 标注后的彩色画面
imshow("threshFrame", motionMask);  // 二值化运动掩码，便于观察算法过程

重叠比例 = (目标框 ∩ 警戒区) 的面积 / 目标框的面积

bool IntrusionDetector::isIntruding(const Rect &target) const
{
    if (target.area() <= 0)
    {
        return false;
    }

    // OpenCV 的 Rect 重载了 & 运算符，直接得到交集矩形，代码非常直观
    const Rect intersection = target & warningArea_;
    const double overlapRatio =
        static_cast<double>(intersection.area()) / target.area();

    return overlapRatio >= minOverlapRatio_;
}

// 手写版：要考虑两矩形各种相对位置，容易出边界错误
int x1 = max(target.x, warningArea_.x);
int y1 = max(target.y, warningArea_.y);
int x2 = min(target.x + target.width, warningArea_.x + warningArea_.width);
int y2 = min(target.y + target.height, warningArea_.y + warningArea_.height);

黄色：警戒区边界，由配置文件固定，画面中始终存在
绿色：运动目标框，尚未进入警戒区
红色：运动目标框，与警戒区重叠比例 ≥ min_overlap_ratio，判定为入侵

NORMAL
  ↓ 检测到入侵，开始累计连续帧数
CHECKING
  ↓ 连续计满 trigger_frames 帧，确认报警
WARNING
  ↓ 连续 clear_frames 帧未检测到入侵，解除报警
NORMAL（回到起点，计数器清零）

IntrusionState IntrusionDetector::update(bool hasIntrusion)
{
    // 每帧开始时清除"刚触发"标记，只有发生状态切换的帧才会置位
    justTriggered_ = false;

    // 报警中：重新检测到入侵就继续报警；连续多帧没入侵才解除
    if (state_ == IntrusionState::Warning)
    {
        if (hasIntrusion)
        {
            clearFrameCount_ = 0;   // 目标还在，重置离开计数
        }
        else if (++clearFrameCount_ >= clearFrames_)
        {
            state_ = IntrusionState::Normal;
            intrusionFrameCount_ = 0;
            clearFrameCount_ = 0;   // 全部清零，为下一次事件重新累计
        }
        return state_;
    }

    // 非报警状态且本帧无入侵：清空计数，回到 NORMAL
    if (!hasIntrusion)
    {
        intrusionFrameCount_ = 0;
        state_ = IntrusionState::Normal;
        return state_;
    }

    // 非报警状态且本帧有入侵：进入 CHECKING 并累计连续帧数
    state_ = IntrusionState::Checking;
    if (intrusionFrameCount_ < triggerFrames_)
    {
        ++intrusionFrameCount_;
    }
    if (intrusionFrameCount_ >= triggerFrames_)
    {
        state_ = IntrusionState::Warning;
        clearFrameCount_ = 0;
        justTriggered_ = true;      // 本帧刚确认报警
    }
    return state_;
}

if (intrusionDetector.justTriggered())
{
    recordingManager.saveIntrusionEvent(displayFrame, currentTime);
}

output/
├── screenshots/       # 入侵确认瞬间的带标注截图
├── recordings/        # 从程序启动就开始的持续分段录像
└── events.csv         # 事件索引：时间 + 截图路径 + 录像路径

event_id,event_time,screenshot_path,recording_path
1,2026-09-07 16:40:56,output/screenshots/2026_0907_164056.jpg,output/recordings/record_2026_0907_164030.avi

bool RecordingManager::rotateIfNeeded()
{
    const double elapsedSeconds = chrono::duration<double>(
        chrono::steady_clock::now() - segmentStartTime_).count();
    if (elapsedSeconds < segmentDurationSeconds_)
    {
        return true;  // 没到分段时间，继续写当前文件
    }

    // 达到时长：先正确关闭旧文件，再用相同参数创建新文件
    close();
    return startRecording(recordingFps_, recordingFrameSize_);
}

if (!recordingStarted)
{
    recordingManager.startRecording(recordingFps, frame.size());
    recordingStarted = true;
}

string TimeUtils::currentDateTime()
{
    const auto now = chrono::system_clock::now();
    const time_t currentTime = chrono::system_clock::to_time_t(now);

    tm localTime{};
    localtime_r(&currentTime, &localTime);  // 线程安全的 localtime

    ostringstream output;
    output << put_time(&localTime, "%Y-%m-%d %H:%M:%S");
    return output.str();
}

const bool readSucceeded = cap.read(frame);
if (!readSucceeded || frame.empty())
{
    // 本地视频读不到下一帧 = 正常播放结束，直接退出
    if (config.sourceType == "file")
    {
        cout << "视频读取结束" << endl;
        break;
    }

    // 摄像头可能偶发失败（USB 抖动等），连续失败满 maxReadFailures 才停止
    ++consecutiveReadFailures;
    if (consecutiveReadFailures >= config.maxReadFailures)
    {
        break;
    }
    // 重试等待期间仍允许用户退出
    if (waitKey(100) == 'q' || waitKey(100) == 27)
    {
        break;
    }
    continue;
}
consecutiveReadFailures = 0;

const vector<Rect> targets = detector.detect(frame, &motionMask);

// 在副本上绘制标注，保证送入检测器的原始画面不被文字和框污染
displayFrame = frame.clone();
rectangle(displayFrame, intrusionDetector.warningArea(), Scalar(0, 255, 255), 2);
for (const Rect &target : targets)
{
    const bool isIntruding = intrusionDetector.isIntruding(target);
    const Scalar boxColor = isIntruding ? Scalar(0, 0, 255) : Scalar(0, 255, 0);
    rectangle(displayFrame, target, boxColor, 2);
}

++processedFrameCount;
const double elapsedSeconds =
    chrono::duration<double>(steady_clock::now() - fpsStartTime).count();
if (elapsedSeconds >= 1.0)
{
    actualFps = processedFrameCount / elapsedSeconds;  // 真实吞吐
    processedFrameCount = 0;
    fpsStartTime = steady_clock::now();
}

灰度化与滤波 → 相邻帧差分 → 二值化 → 形态学闭运算
→ 轮廓提取与面积过滤 → 重叠比例判入侵 → 连续帧状态机确认
→ 报警截图、持续录像与事件日志