工业场景的人物人体识别跟踪

#include <opencv2/opencv.hpp>
#include <opencv2/objdetect.hpp>

#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <vector>


struct Track
{
    int id = -1;
    cv::Rect2d box;
    int missed = 0;
    int age = 0;
};


double IoU(const cv::Rect2d& a, const cv::Rect2d& b)
{
    double interArea = (a & b).area();
    double unionArea = a.area() + b.area() - interArea;
    if (unionArea <= 0.0)
        return 0.0;
    return interArea / unionArea;
}


class SimpleIoUTracker
{
public:
    explicit SimpleIoUTracker(double iouThreshold = 0.3, int maxMissed = 15)
        : iouThreshold_(iouThreshold), maxMissed_(maxMissed)
    {
    }

    void update(const std::vector<cv::Rect>& detections)
    {
        std::vector<int> detMatched(detections.size(), 0);
        std::vector<int> trackMatched(tracks_.size(), 0);

        // Step 1: greedy IoU matching
        for (size_t t = 0; t < tracks_.size(); ++t)
        {
            double bestIou = 0.0;
            int bestDet = -1;

            for (size_t d = 0; d < detections.size(); ++d)
            {
                if (detMatched[d])
                    continue;

                double iou = IoU(tracks_[t].box, detections[d]);
                if (iou > bestIou)
                {
                    bestIou = iou;
                    bestDet = static_cast<int>(d);
                }
            }

            if (bestDet >= 0 && bestIou >= iouThreshold_)
            {
                tracks_[t].box = detections[bestDet];
                tracks_[t].missed = 0;
                tracks_[t].age++;
                detMatched[bestDet] = 1;
                trackMatched[t] = 1;
            }
        }

        // Step 2: unmatched tracks
        for (size_t t = 0; t < tracks_.size(); ++t)
        {
            if (!trackMatched[t])
            {
                tracks_[t].missed++;
                tracks_[t].age++;
            }
        }

        // Step 3: create new tracks
        for (size_t d = 0; d < detections.size(); ++d)
        {
            if (!detMatched[d])
            {
                Track tr;
                tr.id = nextId_++;
                tr.box = detections[d];
                tr.missed = 0;
                tr.age = 1;
                tracks_.push_back(tr);
            }
        }

        // Step 4: remove dead tracks
        tracks_.erase(
            std::remove_if(
                tracks_.begin(),
                tracks_.end(),
                [this](const Track& tr)
                {
                    return tr.missed > maxMissed_;
                }),
            tracks_.end());
    }

    const std::vector<Track>& tracks() const
    {
        return tracks_;
    }

private:
    int nextId_ = 1;
    double iouThreshold_ = 0.3;
    int maxMissed_ = 15;
    std::vector<Track> tracks_;
};


bool isInsidePolygon(const std::vector<cv::Point>& polygon, const cv::Point& p)
{
    return cv::pointPolygonTest(polygon, p, false) >= 0;
}


int main(int argc, char** argv)
{
    std::string source = "0";
    if (argc > 1)
        source = argv[1];

    cv::VideoCapture cap;

    if (source.size() == 1 && std::isdigit(source[0]))
        cap.open(std::stoi(source));
    else
        cap.open(source);

    if (!cap.isOpened())
    {
        std::cerr << "Failed to open source: " << source << std::endl;
        return -1;
    }

    // OpenCV HOG people detector
    cv::HOGDescriptor hog;
    hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());

    SimpleIoUTracker tracker(0.3, 15);

    // 示例危险区域，可按现场相机画面修改
    std::vector<cv::Point> dangerZone = {
        {200, 150},
        {600, 150},
        {700, 500},
        {120, 500},
    };

    cv::Mat frame;

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

        std::vector<cv::Rect> detections;
        std::vector<double> weights;

        // HOG人体检测
        hog.detectMultiScale(
            frame,
            detections,
            weights,
            0,
            cv::Size(8, 8),
            cv::Size(32, 32),
            1.05,
            2.0,
            false);

        // 简单过滤过小框
        std::vector<cv::Rect> filtered;
        for (const auto& box : detections)
        {
            if (box.width > 30 && box.height > 80)
                filtered.push_back(box);
        }

        tracker.update(filtered);

        // 绘制危险区域
        const cv::Point* pts = dangerZone.data();
        int npts = static_cast<int>(dangerZone.size());
        cv::polylines(frame, &pts, &npts, 1, true, cv::Scalar(0, 0, 255), 2);

        for (const auto& tr : tracker.tracks())
        {
            if (tr.missed > 0)
                continue;

            cv::Rect box = tr.box;
            cv::Point center(
                box.x + box.width / 2,
                box.y + box.height / 2);

            bool alarm = isInsidePolygon(dangerZone, center);

            cv::Scalar color = alarm ? cv::Scalar(0, 0, 255) : cv::Scalar(0, 255, 0);

            cv::rectangle(frame, box, color, 2);
            cv::circle(frame, center, 4, color, -1);

            std::string label = "Person ID:" + std::to_string(tr.id);
            cv::putText(
                frame,
                label,
                cv::Point(box.x, std::max(20, box.y - 8)),
                cv::FONT_HERSHEY_SIMPLEX,
                0.6,
                color,
                2);

            if (alarm)
            {
                cv::putText(
                    frame,
                    "ALARM: Person in danger zone",
                    cv::Point(30, 40),
                    cv::FONT_HERSHEY_SIMPLEX,
                    0.9,
                    cv::Scalar(0, 0, 255),
                    3);
            }
        }

        cv::imshow("C++ Human Detection + IoU Tracking", frame);

        int key = cv::waitKey(1);
        if (key == 27)
            break;
    }

    return 0;
}

struct HumanDetection
{
    int class_id = 0;
    float confidence = 0.0f;
    cv::Rect2f box;
};

struct HumanTrack
{
    int track_id = -1;
    cv::Rect2f box;
    cv::Point2f center;
    float confidence = 0.0f;
    int age = 0;
    int missed = 0;
};

struct SafetyEvent
{
    int track_id = -1;
    std::string event_type;
    std::string zone_id;
    int64_t timestamp_ns = 0;
    float risk_score = 0.0f;
};