Python efficiently process high-resolution images and accurately locate white circular areas

This article explores how to efficiently process high-resolution images of 9000x7000 pixels using Python and OpenCV to accurately find two white circular areas. The original code has missed and misdetected problems. The following provides optimization solutions.

Problem description

Objective: Accurately locate two white circular areas in a high-resolution image. The existing code uses the Hough circle transformation, but the result is not ideal and there are a lot of misjudgments.

Optimization strategy

In order to improve detection accuracy, images need to be preprocessed and a more robust detection method is adopted. The following steps are gradually optimized:

1. Image Preprocessing: High-resolution image processing is time-consuming and therefore requires optimization. First of all, when reading an image, you can consider reducing the image size and reducing the calculation complexity, but you need to pay attention to the balance between the size reduction ratio and accuracy. You can use the cv2.resize function and select the appropriate interpolation method (e.g. cv2.INTER_AREA for shrinking).

2. Enhanced contrast: To highlight the white circular area, image contrast can be enhanced. You can use histogram equalization ( cv2.equalizeHist ) or CLAHE (Contrast Limited Adaptive Histogram Equalization, cv2.createCLAHE ). CLAHE can better handle local contrast differences.

3. Threshold segmentation: After converting the image to a grayscale graph, use adaptive threshold segmentation ( cv2.adaptiveThreshold ) instead of a simple global threshold segmentation. Adaptive threshold segmentation can better adapt to the brightness changes in different areas of the image. A suitable adaptive method (e.g. cv2.ADAPTIVE_THRESH_GAUSSIAN_C ) and block size can be selected.

4. Morphological operation: Use morphological opening operations ( cv2.morphologyEx , cv2.MORPH_OPEN ) to remove noise and fine impurities in the image to make the circular area clearer. You need to choose the appropriate structural element size.

5. Contour detection and filtering: Use cv2.findContours function to detect image contours. When filtering outlines, interference items can be eliminated based on features such as the contour area, circumference, and circularity, and only contours that conform to the white circular characteristics are retained. The circularity can be calculated using the contour area and perimeter.

6. Minimum circumference: For the filtered contour, you can use cv2.minEnclosingCircle function to fit the minimum circumference to obtain the center coordinates and radius.

Improved code framework (the parameters need to be adjusted according to the actual image):

 import cv2
import numpy as np

image_path = r"C:\Users\17607\Desktop\smls pictures\Pic_20231122151507973.bmp"

img = cv2.imread(image_path)
img_resized = cv2.resize(img, (img.shape[1] // 4, img.shape[0] // 4), interpolation=cv2.INTER_AREA) #Resize, for example to shrink to 1/4

gray = cv2.cvtColor(img_resized, cv2.COLOR_BGR2GRAY)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
gray = clahe.apply(gray)

thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

kernel = np.ones((5,5), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)

contours, _ = cv2.findContours(opening, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

circles = []
for cnt in contours:
    area = cv2.contourArea(cnt)
    perimeter = cv2.arcLength(cnt, True)
    if perimeter > 0: #Avoid zero-deletion errorscircularity = 4 * np.pi * area / (perimeter ** 2)
        if area > 100 and circuitry > 0.7: #Adjust the threshold (x,y) according to the actual situation, radius = cv2.minEnclosingCircle(cnt)
            circles.append(((int(x), int(y)), int(radius)))

# Draw the result (remember to adjust the coordinates and radius back to the original image according to the scaling ratio)
for (x,y),radius in circles:
    cv2.circle(img, (x*4, y*4), radius*4, (0,255,0), 2) # The scale is 4, remember to modify cv2.imshow('Detected Circles', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Note: Parameters in the code (such as thresholds, kernel size, area, and circularity thresholds for morphological operations) need to be adjusted according to the actual image to obtain the best results. It is recommended to gradually adjust the parameters and observe the results. In addition, consider adding an exception handling mechanism, such as handling the situation where image reading fails. Finally, remember to adjust the coordinates and radius of the detection result back to the original image according to the scaling ratio.

The above is the detailed content of How to optimize processing of high-resolution images in Python to find precise white circular areas?. For more information, please follow other related articles on the PHP Chinese website!