多进程与图像采集：线程采集图像的扩展难题及方案咨询

Hey there, I totally get where you're coming from. Threading can feel like a quick win for camera capture, but once you start trying to scale with queue-based frame handling, the shared memory space and GIL limitations start to cause headaches. Let's walk through why multiprocessing is a better fit here, and drop some working code you can adapt.

Why Multiprocessing Over Threading for This Use Case? #

• Bypasses the GIL: Python's Global Interpreter Lock limits thread performance for CPU-heavy tasks (like image processing). Multiprocessing gives each process its own Python interpreter and memory space, so you can fully utilize multiple cores.
• Safer Inter-Process Communication: The multiprocessing.Queue is purpose-built for passing data between processes, avoiding the race conditions and deadlock risks that can pop up with threading's queue when dealing with resource-heavy frames.
• Cleaner Separation of Concerns: You can isolate capture, processing, and storage into separate processes without worrying about shared state messing things up.

Implementation Code #

First, let's start with a basic OpenCV-only solution that works with most USB cameras and the Raspberry Pi Camera Module (via cv2.VideoCapture):

import cv2
import multiprocessing as mp

def camera_capture_worker(frame_queue, width=640, height=480, fps=30):
    # Initialize camera
    cap = cv2.VideoCapture(0)
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
    cap.set(cv2.CAP_PROP_FPS, fps)

    if not cap.isOpened():
        print("Error: Could not open camera.")
        frame_queue.put(None)  # Send shutdown signal
        return

    try:
        while True:
            ret, frame = cap.read()
            if not ret:
                print("Error: Failed to capture frame.")
                break
            
            # Add frame to queue (blocks if queue is full to prevent memory overload)
            frame_queue.put(frame)
    finally:
        cap.release()
        frame_queue.put(None)  # Notify processing thread to shut down

def frame_processing_worker(frame_queue):
    while True:
        frame = frame_queue.get()
        if frame is None:
            break  # Received shutdown signal
        
        # Add your custom processing here: resize, detect objects, save to disk, etc.
        cv2.imshow("Live Feed", frame)
        
        # Exit on 'q' key press
        if cv2.waitKey(1) & 0xFF == ord('q'):
            frame_queue.put(None)  # Notify capture thread to shut down
            break

    cv2.destroyAllWindows()

if __name__ == "__main__":
    # Create a queue with max size to prevent memory bloat
    frame_queue = mp.Queue(maxsize=10)

    # Spawn capture and processing processes
    capture_process = mp.Process(target=camera_capture_worker, args=(frame_queue,))
    processing_process = mp.Process(target=frame_processing_worker, args=(frame_queue,))

    # Start processes
    capture_process.start()
    processing_process.start()

    # Wait for processing to finish (either via 'q' or capture error)
    processing_process.join()
    capture_process.join()

For Better Performance: Use Picamera2 with OpenCV #

If you're using the official Raspberry Pi Camera Module, picamera2 (the successor to picamera) offers better control over camera settings and more efficient frame capture. Here's how to integrate it with multiprocessing:

First, install dependencies:

pip install opencv-python picamera2

Then the code:

from picamera2 import Picamera2
import cv2
import multiprocessing as mp
import numpy as np

def picamera_capture_worker(frame_queue, width=640, height=480, fps=30):
    picam2 = Picamera2()
    # Configure camera for RGB output (compatible with OpenCV)
    config = picam2.create_preview_configuration(
        main={"size": (width, height), "format": "RGB888"},
        controls={"FrameRate": fps}
    )
    picam2.configure(config)
    picam2.start()

    try:
        while True:
            # Capture frame as a numpy array
            frame = picam2.capture_array()
            frame_queue.put(frame)
    finally:
        picam2.stop()
        frame_queue.put(None)

def frame_processing_worker(frame_queue):
    while True:
        frame = frame_queue.get()
        if frame is None:
            break
        
        # Example processing: convert to grayscale and display
        gray_frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
        cv2.imshow("Grayscale Feed", gray_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            frame_queue.put(None)
            break

    cv2.destroyAllWindows()

if __name__ == "__main__":
    frame_queue = mp.Queue(maxsize=10)

    capture_process = mp.Process(target=picamera_capture_worker, args=(frame_queue,))
    processing_process = mp.Process(target=frame_processing_worker, args=(frame_queue,))

    capture_process.start()
    processing_process.start()

    processing_process.join()
    capture_process.join()

Key Tips for Your Implementation #

• Queue Size: Adjust maxsize based on your Raspberry Pi's memory and processing speed. A smaller queue prevents memory overload, while a larger one can smooth out temporary processing delays.
• Frame Compression: If you're passing large frames between processes, consider compressing them (e.g., using cv2.imencode('.jpg', frame) to send byte streams) to reduce inter-process communication overhead.
• Error Handling: Add try/except blocks around critical sections (like camera initialization and frame capture) to make your code more robust.

内容的提问来源于stack exchange，提问作者Hojo.Timberwolf