Download openvino_sample.py from Intel/crowd-analysis: direct link, hf CLI and curl.
- Browser
- Download file 4.79 kB
-
https://huggingface.co/Intel/crowd-analysis/resolve/main/openvino_sample.py
- Command line
-
hf download hf://Intel/crowd-analysis/openvino_sample.py
-
curl -L -o openvino_sample.py https://huggingface.co/Intel/crowd-analysis/resolve/main/openvino_sample.py
4.79 kB
| # SPDX-License-Identifier: MIT | |
| # Copyright (C) Intel Corporation | |
| # | |
| # Crowd Analysis: OpenVINO Runtime sample. | |
| # See README.md for prerequisites and inputs. Run: python3 openvino_sample.py | |
| import cv2 | |
| import numpy as np | |
| import openvino as ov | |
| PERSON_CLASS_ID = 0 | |
| CONF_THRESHOLD = 0.4 | |
| # Select the model: "yolo26n" (default) or "detr-resnet-50". | |
| MODEL = "yolo26n" | |
| INPUT_SIZE = 800 if MODEL.startswith("detr") else 640 | |
| # Crowd-density thresholds (person count per frame). | |
| DENSITY_LOW_MAX = 10 # fewer than 10 -> LOW | |
| DENSITY_MEDIUM_MAX = 25 # 10-25 -> MEDIUM, more than 25 -> HIGH | |
| # Movement tracking. | |
| IOU_MATCH_THRESHOLD = 0.3 | |
| MAX_MISSED_FRAMES = 15 | |
| def density_level(count): | |
| if count < DENSITY_LOW_MAX: | |
| return "LOW", (0, 200, 0) | |
| if count <= DENSITY_MEDIUM_MAX: | |
| return "MEDIUM", (0, 200, 255) | |
| return "HIGH", (0, 0, 255) | |
| def iou(box_a, box_b): | |
| ax1, ay1, ax2, ay2 = box_a | |
| bx1, by1, bx2, by2 = box_b | |
| ix1, iy1 = max(ax1, bx1), max(ay1, by1) | |
| ix2, iy2 = min(ax2, bx2), min(ay2, by2) | |
| inter = max(0, ix2 - ix1) * max(0, iy2 - iy1) | |
| if inter == 0: | |
| return 0.0 | |
| area_a = max(0, ax2 - ax1) * max(0, ay2 - ay1) | |
| area_b = max(0, bx2 - bx1) * max(0, by2 - by1) | |
| return inter / float(area_a + area_b - inter) | |
| class CentroidTracker: | |
| """Minimal IoU tracker that records each track's last centroid so we can | |
| estimate per-frame movement (flow) vectors.""" | |
| def __init__(self): | |
| self._next_id = 1 | |
| self._tracks = {} # id -> {"box", "centroid", "missed"} | |
| def update(self, boxes): | |
| unmatched = set(self._tracks) | |
| assignments, moves = [], [] | |
| for box in boxes: | |
| cx = (box[0] + box[2]) / 2.0 | |
| cy = (box[1] + box[3]) / 2.0 | |
| best_id, best_iou = None, IOU_MATCH_THRESHOLD | |
| for tid in unmatched: | |
| score = iou(box, self._tracks[tid]["box"]) | |
| if score > best_iou: | |
| best_id, best_iou = tid, score | |
| if best_id is not None: | |
| tid = best_id | |
| unmatched.discard(tid) | |
| pcx, pcy = self._tracks[tid]["centroid"] | |
| moves.append((cx - pcx, cy - pcy)) | |
| else: | |
| tid = self._next_id | |
| self._next_id += 1 | |
| self._tracks[tid] = {"box": box, "centroid": (cx, cy), "missed": 0} | |
| assignments.append((box, tid)) | |
| for tid in unmatched: | |
| self._tracks[tid]["missed"] += 1 | |
| if self._tracks[tid]["missed"] > MAX_MISSED_FRAMES: | |
| del self._tracks[tid] | |
| return assignments, moves | |
| core = ov.Core() | |
| model = core.read_model(f"{MODEL}_openvino_model/{MODEL}.xml") | |
| compiled = core.compile_model(model, "CPU") # or "GPU", "NPU" | |
| cap = cv2.VideoCapture("test_video.mp4") | |
| fps = cap.get(cv2.CAP_PROP_FPS) or 30.0 | |
| width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) | |
| height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) | |
| writer = cv2.VideoWriter( | |
| "output_openvino.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height)) | |
| tracker = CentroidTracker() | |
| while True: | |
| ok, frame = cap.read() | |
| if not ok: | |
| break | |
| h0, w0 = frame.shape[:2] | |
| sx, sy = w0 / INPUT_SIZE, h0 / INPUT_SIZE | |
| blob = cv2.resize(frame, (INPUT_SIZE, INPUT_SIZE)) | |
| blob = cv2.cvtColor(blob, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0 | |
| blob = blob.transpose(2, 0, 1)[np.newaxis, ...] # NCHW | |
| # End-to-end output: [1, N, 6] = [x1, y1, x2, y2, confidence, class_id] | |
| # (N = 300 for YOLO26, 100 for DETR) | |
| output = compiled([blob])[compiled.output(0)][0] | |
| mask = (output[:, 4] >= CONF_THRESHOLD) & (output[:, 5].astype(int) == PERSON_CLASS_ID) | |
| dets = output[mask] | |
| boxes = [(d[0] * sx, d[1] * sy, d[2] * sx, d[3] * sy) for d in dets] | |
| assignments, moves = tracker.update(boxes) | |
| for box, _tid in assignments: | |
| x1, y1, x2, y2 = (int(v) for v in box) | |
| cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2) | |
| count = len(boxes) | |
| level, color = density_level(count) | |
| cv2.putText(frame, f"Crowd: {count} ({level})", (10, 40), | |
| cv2.FONT_HERSHEY_SIMPLEX, 1.0, color, 2) | |
| # Movement: mean of all per-track displacements -> dominant flow arrow. | |
| if moves: | |
| mdx = float(np.mean([m[0] for m in moves])) | |
| mdy = float(np.mean([m[1] for m in moves])) | |
| ox, oy = width // 2, height - 40 | |
| cv2.arrowedLine(frame, (ox, oy), | |
| (int(ox + mdx * 10), int(oy + mdy * 10)), | |
| (255, 0, 0), 3, tipLength=0.3) | |
| cv2.putText(frame, f"Flow dx={mdx:+.1f} dy={mdy:+.1f}", (10, 75), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2) | |
| writer.write(frame) | |
| cap.release() | |
| writer.release() | |
| print("Saved: output_openvino.mp4") | |