如何在Python中计算未知坐标的多颜色曲线面积并批量处理？

Hey there! Let's tackle your two curve area calculation problems in Python—they're totally solvable with a mix of image processing and numerical computation tools. Here's how to approach each one:

First, since you're starting from an image (not raw coordinate data), the key steps are: extract the curve from the image, convert pixel units to centimeters, then compute the area under/around the curve.

Step-by-Step Breakdown: #

1. Calibrate Pixel-to-Centimeter Ratio
   You need a reference scale in your image (like a ruler) to convert pixels to real-world cm. For example, if a 5cm ruler segment takes up 100 pixels in the image, your conversion factor is 0.05 cm/pixel.

   # Example calibration
   reference_cm = 5.0
   reference_pixels = 100
   pixel_to_cm = reference_cm / reference_pixels
   

2. Extract the Curve from the Image
   Use OpenCV to detect edges and extract the curve's contour. Let's assume your curve is a dark line on a light background:

   import cv2
   import numpy as np
   
   # Load image and preprocess
   img = cv2.imread("your_curve_image.jpg")
   gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
   # Edge detection (adjust thresholds based on your image)
   edges = cv2.Canny(gray, 50, 150)
   # Extract contours
   contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
   # Assuming the largest contour is your curve (adjust if multiple curves exist)
   curve_contour = max(contours, key=cv2.contourArea)
   

3. Convert Contour Coordinates to cm and Calculate Area
   Convert the contour's pixel coordinates to cm, then use numerical integration or OpenCV's built-in area function (adjusted for unit conversion):

   # Convert contour to cm (contour is in (x,y) pixel pairs)
   curve_cm = curve_contour * pixel_to_cm
   # Calculate area using OpenCV (returns area in cm² since we scaled coordinates)
   area_cm2 = cv2.contourArea(curve_cm)
   # Alternatively, use numerical integration if you need area under the curve (not enclosed)
   # Sort points by x-coordinate first
   curve_cm_sorted = sorted(curve_cm[:, 0, :], key=lambda x: x[0])
   x = np.array([p[0] for p in curve_cm_sorted])
   y = np.array([p[1] for p in curve_cm_sorted])
   area_under_curve = np.trapz(y, x)  # Simpson's rule is also an option via scipy.integrate.simpson
   

For curves with distinct colors, the plan is: segment the image by color, extract each color's curve contour, then repeat the steps from Problem 1 for each curve.

Step-by-Step Breakdown: #

1. Define Color Ranges for Each Curve
   Use HSV color space (more robust to lighting changes than RGB) to create masks for each color. You can use tools like OpenCV's cv2.inRange to get masks for each color:

   # Convert image to HSV
   hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
   
   # Example color ranges (adjust these values for your specific colors)
   color_ranges = {
       "red": ([0, 120, 70], [10, 255, 255]),
       "blue": ([94, 80, 2], [126, 255, 255]),
       "green": ([25, 52, 72], [102, 255, 255])
   }
   
   # Map each color to its corresponding value (as per your project)
   color_values = {
       "red": 10,
       "blue": 20,
       "green": 30
   }
   

2. Process Each Color to Calculate Area
   Loop through each color, create a mask, extract the contour, compute area, and pair it with the color's value:

   results = {}
   for color_name, (lower, upper) in color_ranges.items():
       # Create mask for the color
       lower_hsv = np.array(lower, dtype=np.uint8)
       upper_hsv = np.array(upper, dtype=np.uint8)
       mask = cv2.inRange(hsv, lower_hsv, upper_hsv)
       # Extract contours from the mask
       contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
       if contours:
           # Take the largest contour (adjust if multiple curves per color)
           curve_contour = max(contours, key=cv2.contourArea)
           # Convert to cm and calculate area
           curve_cm = curve_contour * pixel_to_cm
           area_cm2 = cv2.contourArea(curve_cm)
           # Store result with color and its value
           results[color_name] = {
               "value": color_values[color_name],
               "area_cm2": round(area_cm2, 2)
           }
   
   # Print out results
   for color, data in results.items():
       print(f"Color: {color}, Value: {data['value']}, Area: {data['area_cm2']} cm²")
   

Notes: #

• If your curves are not enclosed (e.g., just lines, not closed shapes), use numerical integration (np.trapz or scipy.integrate.simpson) instead of cv2.contourArea.
• Adjust edge detection thresholds and color ranges based on your specific image—test with small tweaks to get the best contour extraction.
• For more precise area calculations, consider smoothing the contour points first (e.g., using cv2.approxPolyDP with a small epsilon).

内容的提问来源于stack exchange，提问作者Prem Raheja