Hey, let's break down how to make this work. Your core need is a way for script C to coordinate with A and B—telling them when to show or hide their video windows based on your logic. Here's a practical, Python-native approach using multiprocessing and inter-process communication (IPC):

Core Concepts #

• Inter-Process Communication (IPC): Script C will send control commands ("show" / "hide") to A and B via a Queue (from Python's multiprocessing module). This is lightweight, thread-safe, and works across Windows/macOS/Linux.
• Window Toggle Logic: Each camera script (A/B) runs two parallel tasks: one to capture and display video, another to listen for control commands from C. When a command arrives, it adjusts its window's visibility.

Step-by-Step Implementation (OpenCV + Multiprocessing) #

1. Camera Scripts (A & B) #

Both scripts follow the same structure—we'll use script A as an example, just swap the camera index and window name for script B. We use a thread to listen for commands so the video feed doesn't stutter.

# script_a.py
import cv2
import threading
from multiprocessing import Queue

def run_camera(control_queue):
    # Initialize camera (0 = first camera, change to 1 for B)
    cap = cv2.VideoCapture(0)
    window_name = "Camera A"
    cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
    is_window_visible = True

    # Thread to listen for control commands from C
    def listen_for_commands():
        nonlocal is_window_visible
        while True:
            cmd = control_queue.get()
            if cmd == "show":
                if not is_window_visible:
                    cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
                    is_window_visible = True
            elif cmd == "hide":
                if is_window_visible:
                    cv2.destroyWindow(window_name)
                    is_window_visible = False
            elif cmd == "exit":
                break  # Exit thread when told to

    # Start the command listener thread (daemon = auto-kill when main process ends)
    control_thread = threading.Thread(target=listen_for_commands, daemon=True)
    control_thread.start()

    # Main video capture loop
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break  # Exit if camera disconnects
        
        # Only show frame if window is visible
        if is_window_visible:
            cv2.imshow(window_name, frame)
        
        # Allow exit with 'q' key
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # Cleanup
    cap.release()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    # For testing alone: create a dummy queue (C will provide the real one)
    dummy_queue = Queue()
    run_camera(dummy_queue)

2. Control Script C #

This script starts A and B as separate processes, sets up communication queues, and decides which window to show based on your custom logic.

# script_c.py
from multiprocessing import Process, Queue
import script_a
import script_b
import time

def decide_active_camera(a_processed_data, b_processed_data):
    # Replace this with your actual logic!
    # Example: Alternate between A and B every 3 seconds
    return "A" if int(time.time()) % 6 < 3 else "B"

def main():
    # Create queues to send commands to A and B
    a_control_queue = Queue()
    b_control_queue = Queue()

    # Start A and B as separate processes
    process_a = Process(target=script_a.run_camera, args=(a_control_queue,))
    process_b = Process(target=script_b.run_camera, args=(b_control_queue,))
    process_a.start()
    process_b.start()

    # Initial state: Show A, hide B
    a_control_queue.put("show")
    b_control_queue.put("hide")

    try:
        while True:
            # Simulate receiving processed data from A and B
            # In real code, add another queue for A/B to send results to C
            a_data = "processed_frame_from_a"
            b_data = "processed_frame_from_b"

            # Decide which camera to show
            active_cam = decide_active_camera(a_data, b_data)
            if active_cam == "A":
                a_control_queue.put("show")
                b_control_queue.put("hide")
            else:
                a_control_queue.put("hide")
                b_control_queue.put("show")
            
            time.sleep(1)  # Adjust loop speed as needed
    except KeyboardInterrupt:
        # Cleanup on Ctrl+C
        a_control_queue.put("exit")
        b_control_queue.put("exit")
        process_a.join()
        process_b.join()

if __name__ == "__main__":
    main()

Pro Tips for Better Performance #

• Smoother Window Toggles: OpenCV's destroyWindow/namedWindow can cause minor flicker. For a better experience, use system-level APIs:
  • Windows: Install pywin32 and use win32gui to find the window handle, then call win32gui.ShowWindow(hwnd, 0) to hide, win32gui.ShowWindow(hwnd, 1) to show.
  • Linux: Use the wmctrl command-line tool (install via sudo apt install wmctrl), then call subprocess.run(["wmctrl", "-r", "Camera A", "-b", "toggle,hidden"]).
  • macOS: Use osascript via subprocess: subprocess.run(["osascript", "-e", 'tell application "Python" to set visible of window "Camera A" to false']).
• Result Feedback: If you need A/B to send processed video data to C, add another Queue for each process to push results into—C can read from these queues to make its decisions.
• Robust IPC: For more complex commands (like resizing windows), use multiprocessing.Pipe instead of Queue for direct two-way communication.

内容的提问来源于stack exchange，提问作者Vipul J