基于OpenCV无播放处理预录视频，快速提取跨线人脸

Absolutely! You can absolutely process pre-recorded videos without playing them—this is actually the standard approach for batch video analysis, and with a few optimizations, you can crunch through a 2-hour video in just minutes. Let’s walk through how to adapt your existing code and supercharge the workflow:

Instead of streaming the video to a display (which adds unnecessary overhead), we’ll directly read frames from the video file using OpenCV, process them in bulk, and skip any playback-related code entirely. The key is to minimize redundant computations and leverage faster detection models.

Here’s how to adjust your existing code to work offline efficiently:

1. Replace Live Capture with File Reading #

Swap out your camera capture (e.g., cv2.VideoCapture(0)) with direct file access:

cap = cv2.VideoCapture("your_2hour_video.mp4")

You can also enable hardware acceleration if your system supports it (this cuts down frame read time drastically):

cap.set(cv2.CAP_PROP_HW_ACCELERATION, cv2.CAP_PROP_HW_ACCELERATION_ANY)

2. Ditch Playback Code #

Remove all cv2.imshow() and cv2.waitKey() calls—these are only for displaying video, which we don’t need here. This alone saves a ton of CPU/GPU cycles.

3. Implement Frame Skipping #

You don’t need to process every single frame (most videos are 24-30fps, and a human crossing a line won’t move that fast). Skip N frames at a time to reduce workload:

FRAME_SKIP = 5  # Adjust based on your video's FPS and accuracy needs
frame_count = 0

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    frame_count += 1
    if frame_count % FRAME_SKIP != 0:
        continue
    # Rest of your processing logic here

4. Reuse Your Cross-Line Detection Logic #

Keep your existing code that checks if a face’s center crosses the specified line—this logic works exactly the same on offline frames as it does on live video.

5. Optimize Face Saving #

Pre-create your save directory to avoid repeated checks, and use unique filenames (like timestamps or frame numbers) to prevent overwrites:

import os
from datetime import datetime

SAVE_DIR = "crossing_faces"
os.makedirs(SAVE_DIR, exist_ok=True)

# When saving a face:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
save_path = os.path.join(SAVE_DIR, f"face_{timestamp}.jpg")
cv2.imwrite(save_path, face_img, [cv2.IMWRITE_JPEG_QUALITY, 80])  # Adjust quality to balance size/speed

To get from hours of processing to minutes, you need to speed up face detection and parallelize work:

Switch to a Faster Face Detector #

Haar cascades are slow—swap them for YOLOv8-Face or MTCNN. YOLOv8 is especially fast, even on CPU, and can detect faces in milliseconds per frame. Here’s how to integrate it:

from ultralytics import YOLO
model = YOLO("yolov8n-face.pt")  # Lightweight model for speed

# In your processing loop:
results = model(frame, conf=0.5)  # Adjust confidence threshold as needed
for result in results:
    for box in result.boxes:
        x1, y1, x2, y2 = map(int, box.xyxy[0])
        face_center_y = (y1 + y2) // 2
        # Cross-line check here

Use Hardware Acceleration #

If you have an NVIDIA GPU, enable CUDA support in OpenCV and use GPU-accelerated models. YOLOv8 automatically uses CUDA if available, which can speed up detection by 5-10x.

Parallelize Processing #

Split the workflow into separate threads/processes:

• One thread reads frames from the video file
• Another thread runs face detection
• A third thread saves the detected faces to disk

This prevents IO operations (like saving files) from blocking the detection pipeline.

Here’s a complete, optimized script that puts all these pieces together:

import cv2
import os
from datetime import datetime
from ultralytics import YOLO

# Configuration
VIDEO_PATH = "2hour_video.mp4"
LINE_Y = 400  # Your detection line's Y-coordinate
SAVE_DIR = "crossing_faces"
FRAME_SKIP = 5
CONFIDENCE_THRESHOLD = 0.5

# Setup
os.makedirs(SAVE_DIR, exist_ok=True)
cap = cv2.VideoCapture(VIDEO_PATH)
cap.set(cv2.CAP_PROP_HW_ACCELERATION, cv2.CAP_PROP_HW_ACCELERATION_ANY)
model = YOLO("yolov8n-face.pt")

frame_count = 0
print("Starting video processing...")

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    frame_count += 1
    if frame_count % FRAME_SKIP != 0:
        continue

    # Detect faces
    results = model(frame, conf=CONFIDENCE_THRESHOLD)
    for result in results:
        for box in result.boxes:
            x1, y1, x2, y2 = map(int, box.xyxy[0])
            face_center_y = (y1 + y2) // 2

            # Check if face crosses the line (with small tolerance)
            if abs(face_center_y - LINE_Y) < 10:
                face_img = frame[y1:y2, x1:x2]
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
                save_path = os.path.join(SAVE_DIR, f"face_{timestamp}.jpg")
                cv2.imwrite(save_path, face_img, [cv2.IMWRITE_JPEG_QUALITY, 80])
                print(f"Saved: {save_path}")

cap.release()
print("Processing complete!")

• Test FRAME_SKIP with a short clip first—balance between speed and accuracy.
• If you’re on CPU, stick to YOLOv8n (nano) for the fastest performance.
• For extremely large videos, consider splitting the video into chunks and processing them in parallel with multiple scripts.

内容的提问来源于stack exchange，提问作者Imangali Turar