feat: update with claude code

mv-and-ip/car_plate.py

@@ -7,244 +7,93 @@ import logging
 from pathlib import Path
 from dataclasses import dataclass
 
-def _uniform_car_plate(img: cv.typing.MatLike) -> cv.typing.MatLike:
-    """
-    Uniform the image size to 512x512 while maintaining aspect ratio, padding with black.
-
-    :param img: The image in BGR format to be uniformed.
-    :return: The uniformed image in BGR format.
-    """
-    UNI_HW: int = 512
-    
-    # Calculate the new width and height for given image
-    h, w = img.shape[:2]
-    scale = min(UNI_HW / w, UNI_HW / h)
-    new_w = int(w * scale)
-    new_h = int(h * scale)
-    
-    # Resize the image
-    resized_img = cv.resize(img, (new_w, new_h))
-    
-    # Create a black canvas of size UNI_HW x UNI_HW
-    padded_img = np.zeros((UNI_HW, UNI_HW, 3), dtype=np.uint8)
-    
-    # Calculate position to paste the resized image (centered)
-    y_offset = (UNI_HW - new_h) // 2
-    x_offset = (UNI_HW - new_w) // 2
-    
-    # Paste the resized image onto the canvas
-    padded_img[y_offset:y_offset+new_h, x_offset:x_offset+new_w] = resized_img
-    
-    # Return the padded image
-    return padded_img
-
-
 def extract_car_plate(img: cv.typing.MatLike) -> typing.Optional[cv.typing.MatLike]:
     """Extract the car plate part from given image.
 
     :param img: The image containing car plate in BGR format.
     :return: The image of binary car plate in U8 format if succeed, otherwise None.
     """
-    # Reference: https://www.cnblogs.com/linuxAndMcu/p/19144795
+    # ── 1. 利用蓝色车牌颜色在 HSV 空间定位车牌 ──────────────────────────
+    hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)
+    # 中国蓝牌 HSV 范围
+    lower_blue = np.array([100, 80, 60])
+    upper_blue = np.array([130, 255, 255])
+    mask_blue = cv.inRange(hsv, lower_blue, upper_blue)
 
-    # Resize the image to make following step works about finding proper contours.
+    # 形态学：闭运算填孔 + 开运算去噪
-    img = _uniform_car_plate(img)
+    kernel_close = cv.getStructuringElement(cv.MORPH_RECT, (25, 10))
+    kernel_open  = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
+    mask_blue = cv.morphologyEx(mask_blue, cv.MORPH_CLOSE, kernel_close)
+    mask_blue = cv.morphologyEx(mask_blue, cv.MORPH_OPEN,  kernel_open)
 
-    # Convert to grayscale image
+    # ── 2. 连通域分析，筛选最符合车牌长宽比的区域 ──────────────────────
-    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+    num_labels, labels, stats, _ = cv.connectedComponentsWithStats(mask_blue, connectivity=8)
 
-    # Histogram balance to increase contrast
+    best = None
-    hist_gray = cv.equalizeHist(gray)
+    best_score = 0
+    h_img, w_img = img.shape[:2]
 
-    # Apply Gaussian blur to reduce noise
+    for i in range(1, num_labels):
-    blurred = cv.GaussianBlur(hist_gray, (5, 5), 0)
+        x, y, w, h, area = stats[i]
-    
+        if area < 3000:
-    # Edge detection using Canny
-    edges = cv.Canny(blurred, 50, 150)
-
-    # cv.imshow('contours', edges)
-    # k = cv.waitKey(0)
-    # return None
-    
-    # Morphological operations to connect broken edges
-    kernel_close = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
-    closed = cv.morphologyEx(edges, cv.MORPH_CLOSE, kernel_close)
-    kernel_open = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
-    opened = cv.morphologyEx(closed, cv.MORPH_OPEN, kernel_open)
-    kernel_dilate = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
-    dilated = cv.dilate(edges, kernel_dilate, iterations=2)
-
-    cv.imshow('contours', opened)
-    k = cv.waitKey(0)
-    return None
-    
-    # Find contours
-    contours, _ = cv.findContours(closed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        logging.error("No contours found")
-        return None
-    # List all contours
-    logging.debug(f'Total {len(contours)} contours.')
-    for i, contour in enumerate(contours):
-        logging.debug(f'Contour[{i}] has {contour.shape[0]} points.')
-    
-    cv.drawContours(img, contours, -1, (0, 0, 255), 3)
-    cv.imshow('contours', img)
-    k = cv.waitKey(0)
-    return None
-
-    # Filter contours
-    candidates: list[cv.typing.MatLike] = []
-    MIN_AREA: float = 2000
-    MAX_AREA: float = 100000
-    MIN_ASPECT_RATIO: float = 2.5
-    MAX_ASPECT_RATIO: float = 6.0
-
-    for i, contour in enumerate(contours):
-        # Calculate the area
-        area = cv.contourArea(contour)
-        if area < MIN_AREA or area > MAX_AREA:
-            logging.debug(f'Contour[{i}] failed at area limit. The area of this contour is {area}.')
             continue
+        ratio = w / (h + 1e-5)
+        # 标准车牌宽高比约 3:1 ~ 5:1
+        if 2.5 < ratio < 6.0:
+            score = area * (1 - abs(ratio - 3.5) / 3.5)
+            if score > best_score:
+                best_score = score
+                best = (x, y, w, h)
 
-        # Get bounding rectangle
+    assert best is not None, "未找到车牌区域"
-        bouding_rect = cv.boundingRect(contour)
+    x, y, w, h = best
-        (x, y, w, h) = bouding_rect
+    # 稍微扩边
-        # Calaulate aspect ratio
+    pad = 6
-        aspect_ratio = w / h
+    x1 = max(x - pad, 0)
-        if aspect_ratio < MIN_ASPECT_RATIO or aspect_ratio > MAX_ASPECT_RATIO:
+    y1 = max(y - pad, 0)
-            logging.debug(f'Contour[{i}] failed at aspect ratio limit. The aspect ratio of this contour is {aspect_ratio}.')
+    x2 = min(x + w + pad, w_img)
-            continue
+    y2 = min(y + h + pad, h_img)
 
-        # Get the convex hull of contour
+    plate_color = img[y1:y2, x1:x2].copy()
-        hull = cv.convexHull(contour)
+    print(f"车牌区域: x={x1}, y={y1}, w={x2-x1}, h={y2-y1}")
 
-        # Compute the occupation of contour area in convex hull area
+    # # 在原图上标记（仅供调试）
-        hull_area = cv.contourArea(hull)
+    # debug = img.copy()
-        solidity = area / hull_area
+    # cv.rectangle(debug, (x1, y1), (x2, y2), (0, 255, 0), 3)
+    # cv.imwrite('./debug_detected.jpg', debug)
 
-        # Filter more regular contour
+    # ── 3. 二值化：文字/边缘 → 黑色，背景 → 白色 ─────────────────────
-        if solidity > 0.6:
+    gray = cv.cvtColor(plate_color, cv.COLOR_BGR2GRAY)
-            # Extra check for the rectangle fill rate
-            fill_ratio = area / (w * h)
-            if fill_ratio > 0.3:
-                logging.debug(f'Contour[{i}] is perfect.')
-                candidates.append(contour)
-                continue
-            else:
-                logging.debug(f'Contour[{i}] failed at rectangle fill ratio limit. The fill ratio of this contour is {fill_ratio}')
-        else:
-            logging.debug(f'Contour[{i}] failed at solidity limit. The solidity of this contour is {solidity}.')
 
-    if len(candidates) == 0:
+    # 高斯模糊降噪
-        logging.error("No candidate contour")
+    blurred = cv.GaussianBlur(gray, (3, 3), 0)
-        return None
 
-    cv.drawContours(img, contours, -1, (0, 0, 255), 3)
+    # Otsu 自动阈值，得到白字黑底，再取反 → 黑字白底
-    cv.imshow('contours', img)
+    _, binary_otsu = cv.threshold(blurred, 0, 255,
-    k = cv.waitKey(0)
+                                cv.THRESH_BINARY + cv.THRESH_OTSU)
-    return None
+    binary = cv.bitwise_not(binary_otsu)          # 反转：字符变黑，背景变白
 
+    # 去除小噪点（开运算）
+    kernel_denoise = cv.getStructuringElement(cv.MORPH_RECT, (2, 2))
+    binary = cv.morphologyEx(binary, cv.MORPH_OPEN, kernel_denoise)
 
+    return binary
+    # cv.imwrite('./plate_binary.png', binary)
+    # print("二值化结果已保存: plate_binary.png")
 
-    # Step 6: Find the most likely license plate contour
+    # ── 4. 叠加边框轮廓（细化文字边缘，参考效果图）─────────────────────
-    # License plates are typically rectangular with specific aspect ratios
+    # Canny 边缘叠加让效果更接近参考图
-    max_area = 0
+    edges = cv.Canny(blurred, 40, 120)
-    best_contour = None
+    edges_inv = cv.bitwise_not(edges)             # 边缘→黑色
+    combined = cv.bitwise_and(binary, edges_inv)  # 合并
+    # 再做一次轻微腐蚀让字体略粗
+    kernel_dilate = cv.getStructuringElement(cv.MORPH_RECT, (2, 2))
+    combined = cv.erode(combined, kernel_dilate, iterations=1)
 
-    for contour in contours:
+    return combined
-        area = cv.contourArea(contour)
+    # cv.imwrite('./plate_final.png', combined)
-        if area < 500:  # Filter out small contours
+    # print("最终结果已保存: plate_final.png")
-            continue
 
-        # Approximate the contour
-        peri = cv.arcLength(contour, True)
-        approx = cv.approxPolyDP(contour, 0.02 * peri, True)
-        
-        # Look for quadrilateral shapes (4 corners)
-        if len(approx) == 4:
-            x, y, w, h = cv.boundingRect(contour)
-            aspect_ratio = float(w) / h if h > 0 else 0
-            
-            # Typical license plate aspect ratio is between 2 and 5
-            if 2 <= aspect_ratio <= 5 and area > max_area:
-                max_area = area
-                best_contour = approx
-    
-    if best_contour is None:
-        # If no perfect quadrilateral found, try with largest rectangular contour
-        for contour in contours:
-            area = cv.contourArea(contour)
-            if area < 500:
-                continue
-            
-            x, y, w, h = cv.boundingRect(contour)
-            aspect_ratio = float(w) / h if h > 0 else 0
-            
-            if 1.5 <= aspect_ratio <= 6 and area > max_area:
-                max_area = area
-                rect = cv.minAreaRect(contour)
-                box = cv.boxPoints(rect)
-                best_contour = np.int0(box)
-    
-    if best_contour is None:
-        logging.error("No valid contour found")
-        return None
-    
-    # Step 7: Perspective transformation to get front view
-    # Order points: top-left, top-right, bottom-right, bottom-left
-    pts = best_contour.reshape(4, 2)
-    rect = np.zeros((4, 2), dtype="float32")
-    
-    # Sum and difference of coordinates to find corners
-    s = pts.sum(axis=1)
-    rect[0] = pts[np.argmin(s)]  # Top-left has smallest sum
-    rect[2] = pts[np.argmax(s)]  # Bottom-right has largest sum
-    
-    diff = np.diff(pts, axis=1)
-    rect[1] = pts[np.argmin(diff)]  # Top-right has smallest difference
-    rect[3] = pts[np.argmax(diff)]  # Bottom-left has largest difference
-    
-    # Calculate width and height of new image
-    width_a = np.linalg.norm(rect[0] - rect[1])
-    width_b = np.linalg.norm(rect[2] - rect[3])
-    max_width = max(int(width_a), int(width_b))
-    
-    height_a = np.linalg.norm(rect[0] - rect[3])
-    height_b = np.linalg.norm(rect[1] - rect[2])
-    max_height = max(int(height_a), int(height_b))
-    
-    # Destination points for perspective transform
-    dst_pts = np.array([
-        [0, 0],
-        [max_width - 1, 0],
-        [max_width - 1, max_height - 1],
-        [0, max_height - 1]
-    ], dtype="float32")
-    
-    # Get perspective transform matrix and apply it
-    M = cv.getPerspectiveTransform(rect, dst_pts)
-    warped = cv.warpPerspective(img, M, (max_width, max_height))
-
-    # Step 8: Convert warped image to grayscale
-    warped_gray = cv.cvtColor(warped, cv.COLOR_BGR2GRAY)
-    
-    # Step 9: Apply adaptive thresholding for better binarization
-    # First, enhance contrast
-    clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    enhanced = clahe.apply(warped_gray)
-    
-    # Apply Otsu's thresholding to get binary image
-    _, binary = cv.threshold(enhanced, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)
-    
-    # Step 10: Clean up the binary image with morphological operations
-    kernel_clean = cv.getStructuringElement(cv.MORPH_RECT, (2, 2))
-    cleaned = cv.morphologyEx(binary, cv.MORPH_CLOSE, kernel_clean)
-    
-    # Ensure the output is in the correct format (U8)
-    result = cleaned.astype(np.uint8)
-    
-    return result
 
 @dataclass
 class Cli: