基于OpenCV的指定点/线实时颜色变化检测技术方案咨询

Got it, let's figure out how to build that real-time color change detection for specific points or lines—just like the effect you're aiming for. I’ve worked on similar computer vision projects before, so here’s a practical breakdown of the approach plus a working code example to kick things off.

• 1. Real-Time Video Capture
  The foundation is pulling live frames from your camera. OpenCV’s VideoCapture class makes this straightforward—it connects to your default camera (or a specific one) and lets you read frames in a continuous loop.
• 2. Let Users Select Target Points/Lines
  You need a way to let the user pick exactly which area to monitor. A mouse callback function is perfect here: when the user clicks or drags, you’ll record the coordinates of the target point or line endpoints. For single points, one click is enough; for lines, capture two clicks.
• 3. Color Monitoring & Change Detection
  Skip RGB (it’s sensitive to lighting shifts) and use the HSV color space instead—it separates color (hue/saturation) from brightness (value), making color detection way more reliable. Capture a baseline HSV value for your target area once at the start, then compare each new frame’s value against this baseline. Set thresholds (e.g., hue difference > 20, or saturation/value shifts beyond a set range) to trigger a "color change" alert.
• 4. Visual Feedback
  Draw the selected points/lines on the live feed so the user can see what’s being monitored. When a color change is detected, highlight the area (like a red circle/line) and display a clear alert on the frame.

import cv2
import numpy as np

# Global variables to store target points and baseline color
target_points = []
baseline_hsv = None
color_change_detected = False

def mouse_callback(event, x, y, flags, param):
    global target_points, baseline_hsv
    # Left-click to select points (max 2 for a line)
    if event == cv2.EVENT_LBUTTONDOWN:
        if len(target_points) < 2:
            target_points.append((x, y))
            print(f"Selected point: ({x}, {y})")
            # Capture baseline color when two points are selected
            if len(target_points) == 2:
                hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
                # Create a mask for the line segment
                line_mask = np.zeros_like(hsv_frame[:,:,0])
                cv2.line(line_mask, target_points[0], target_points[1], 255, 2)
                # Extract HSV values along the line
                line_hsv = hsv_frame[line_mask == 255]
                if len(line_hsv) > 0:
                    baseline_hsv = np.mean(line_hsv, axis=0)
                    print(f"Baseline HSV: {baseline_hsv.round(2)}")
    # Right-click to reset selection
    elif event == cv2.EVENT_RBUTTONDOWN:
        global color_change_detected
        target_points = []
        baseline_hsv = None
        color_change_detected = False
        print("Selection reset")

# Initialize video capture
cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("Error: Could not access camera")
    exit()

# Create window and set mouse callback
cv2.namedWindow("Real-Time Color Detection")
cv2.setMouseCallback("Real-Time Color Detection", mouse_callback)

# Adjust these thresholds based on your use case
HUE_THRESHOLD = 20
SAT_THRESHOLD = 40
VAL_THRESHOLD = 40

while True:
    ret, frame = cap.read()
    if not ret:
        print("Error: Could not read frame")
        break

    # Draw selected points/lines
    if len(target_points) == 1:
        cv2.circle(frame, target_points[0], 6, (0,255,0), -1)
    elif len(target_points) == 2:
        # Set line color: green = no change, red = change detected
        line_color = (0,0,255) if color_change_detected else (0,255,0)
        cv2.line(frame, target_points[0], target_points[1], line_color, 2)

        # Check for color change if baseline is set
        if baseline_hsv is not None:
            hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
            line_mask = np.zeros_like(hsv_frame[:,:,0])
            cv2.line(line_mask, target_points[0], target_points[1], 255, 2)
            current_hsv = hsv_frame[line_mask == 255]
            
            if len(current_hsv) > 0:
                current_avg = np.mean(current_hsv, axis=0)
                # Calculate differences from baseline
                h_diff = abs(current_avg[0] - baseline_hsv[0])
                s_diff = abs(current_avg[1] - baseline_hsv[1])
                v_diff = abs(current_avg[2] - baseline_hsv[2])

                # Trigger alert if any threshold is exceeded
                if h_diff > HUE_THRESHOLD or s_diff > SAT_THRESHOLD or v_diff > VAL_THRESHOLD:
                    color_change_detected = True
                    cv2.putText(frame, "COLOR CHANGE DETECTED!", (50,50), 
                                cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2)
                else:
                    color_change_detected = False

    # Display instructions
    cv2.putText(frame, "Left-click to select 1/2 points | Right-click to reset", 
                (10, frame.shape[0]-20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 1)

    # Show live feed
    cv2.imshow("Real-Time Color Detection", frame)

    # Exit on 'q' key press
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

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

• Tweak Thresholds: The HUE/SAT/VAL values in the code are starting points—adjust them based on how sensitive you need the detection to be. Test with your specific color shifts to find the right balance.
• Reduce Noise: Add a Gaussian blur (cv2.GaussianBlur(frame, (5,5), 0)) to frames before processing to minimize camera noise, which can trigger false detections.
• Single Point Detection: If you only need to monitor a single pixel, modify the code to capture one point and extract its HSV value directly (instead of a line segment).
• Lighting Stability: For environments with varying lighting, normalize the value channel or use adaptive thresholding to make detection more consistent.

内容的提问来源于stack exchange，提问作者Abdullah Sinanoglu