""" 尿检试纸颜色识别 - 核心算法模块 基于鸿蒙C++代码 (PaperRecognizer + ColorReader + PaperConfig) 的Python重写 Author: 小月 Date: 2026-05-03 """ import cv2 import numpy as np import math import logging from dataclasses import dataclass, field from enum import Enum from typing import List, Tuple, Optional logger = logging.getLogger("urine_recognizer") # ============================================================================= # 枚举类型 (Types.h) # ============================================================================= class BlockItems(Enum): BI_14 = 14 BI_11 = 11 BI_8 = 8 class BigLocatorType(Enum): BLT_SHORT = 0 # 10mm BLT_LONG = 1 # 15mm class LocatorColor(Enum): UNKNOWN = 0 RED = 1 GREEN = 2 BLUE = 3 class PaperSpatialType(Enum): PST_UNKNOWN = 0 PST_14_S = 1 # 14联, 10mm大定位块 PST_14_L = 2 # 14联, 15mm大定位块 PST_11_S = 3 # 11联, 10mm大定位块 PST_11_L = 4 # 11联, 15mm大定位块 PST_8_S = 5 # 8联, 10mm大定位块 PST_8_L = 6 # 8联, 15mm大定位块 class BlurLevel(Enum): BLUR_NONE = 0 # 清晰 (>300) BLUR_SLIGHT = 1 # 轻微模糊 (100-300) BLUR_SEVERE = 2 # 严重模糊 (<100) # ============================================================================= # 检测项目名称 (14/11/8项) # ============================================================================= # 尿常规14项名称（id=0靠近小定位块，依次向大定位块方向） # 来源：蔡叔叔确认的红色14联试纸实际排列 (2026-05-03) ITEM_NAMES_14 = [ "葡萄糖(GLU)", # 0 "白细胞(LEU)", # 1 "亚硝酸盐(NIT)", # 2 "尿胆原(URO)", # 3 "胆红素(BIL)", # 4 "酮体(KET)", # 5 "比重(SG)", # 6 "潜血(BLD)", # 7 "pH", # 8 "尿蛋白(PRO)", # 9 "微量白蛋白(MA)", # 10 "肌酐(CRE)", # 11 "尿钙(Ca)", # 12 "抗坏血酸(VC)", # 13 ] # 尿常规11项名称 ITEM_NAMES_11 = [ "抗坏血酸(VC)", "葡萄糖(GLU)", "胆红素(BIL)", "酮体(KET)", "比重(SG)", "潜血(BLD)", "pH", "蛋白质(PRO)", "尿胆原(URO)", "亚硝酸盐(NIT)", "白细胞(LEU)", ] # 尿常规8项名称 ITEM_NAMES_8 = [ "葡萄糖(GLU)", "胆红素(BIL)", "酮体(KET)", "比重(SG)", "潜血(BLD)", "pH", "蛋白质(PRO)", "白细胞(LEU)", ] ITEM_NAMES_MAP = { 14: ITEM_NAMES_14, 11: ITEM_NAMES_11, 8: ITEM_NAMES_8, } # ============================================================================= # 全局参数 (GlobalParams.h) # ============================================================================= COLOR_DISTANCE_THRESHOLD = 180.0 AREA_ERROR_RATIO = 0.20 DISTANCE_ERROR_RATIO = 0.20 ANGLE_ERROR_DEGREE = 15.0 BIG_LOCATOR_RATIO_SHORT = 2.0 # 10mm: 10/5 BIG_LOCATOR_RATIO_LONG = 3.0 # 15mm: 15/5 SMALL_LOCATOR_RATIO = 1.667 # 5/3 AREA_RATIO_SHORT = 3.33 # 10/3 AREA_RATIO_LONG = 5.0 # 15/3 MIN_SAMPLE_PIXELS = 25 DEFAULT_SAMPLE_RADIUS = 3 MIN_CONTOUR_AREA = 100.0 MAX_AREA_RATIO = 0.3 MIN_RECTANGULARITY = 0.70 MAX_LOCATOR_AREA = 20000.0 MIN_SMALL_LOCATOR_AREA = 100.0 MAX_SMALL_LOCATOR_AREA = 8000.0 MIN_BIG_LOCATOR_AREA = 200.0 MAX_BIG_LOCATOR_AREA = 15000.0 COLOR_COMPONENT_THRESHOLD = 0.05 # ============================================================================= # 数据结构 (Types.h) # ============================================================================= @dataclass class LocatorInfo: """定位块信息""" rotated_rect: Optional[cv2.RotatedRect] = None center: Tuple[float, float] = (0.0, 0.0) area: float = 0.0 width: float = 0.0 # 长边 height: float = 0.0 # 短边 color: LocatorColor = LocatorColor.UNKNOWN is_big: bool = False avg_color: Tuple[float, float, float] = (0.0, 0.0, 0.0) # BGR @dataclass class ColorResult: """色块颜色结果""" id: int = 0 r: float = 0.0 g: float = 0.0 b: float = 0.0 h: float = 0.0 s: float = 0.0 v: float = 0.0 l: float = 0.0 a: float = 0.0 b_val: float = 0.0 @dataclass class RecognitionResult: """识别结果""" success: bool = False error_code: int = -1 error_message: str = "" paper_type: PaperSpatialType = PaperSpatialType.PST_UNKNOWN paper_type_name: str = "" locator_color: LocatorColor = LocatorColor.UNKNOWN locator_color_name: str = "" item_count: int = 0 colors: List[ColorResult] = field(default_factory=list) blur_level: int = 0 blur_score: float = 0.0 annotated_image_b64: str = "" # ============================================================================= # 试纸配置 (PaperConfig.h/.cpp) # ============================================================================= @dataclass class PaperConfig: """单个试纸规格配置""" type: PaperSpatialType = PaperSpatialType.PST_UNKNOWN block_items: BlockItems = BlockItems.BI_14 locator_type: BigLocatorType = BigLocatorType.BLT_SHORT items_num: int = 0 slices_num: int = 0 first_pos: float = 0.0 step: float = 0.0 dist_times: float = 0.0 wh_big_ratio: float = 0.0 # 6种规格配置 PAPER_CONFIGS = { PaperSpatialType.PST_14_S: PaperConfig( type=PaperSpatialType.PST_14_S, block_items=BlockItems.BI_14, locator_type=BigLocatorType.BLT_SHORT, items_num=14, slices_num=50, first_pos=2.25, step=3.5, dist_times=21.3, wh_big_ratio=BIG_LOCATOR_RATIO_SHORT, ), PaperSpatialType.PST_14_L: PaperConfig( type=PaperSpatialType.PST_14_L, block_items=BlockItems.BI_14, locator_type=BigLocatorType.BLT_LONG, items_num=14, slices_num=50, first_pos=2.25, step=3.5, dist_times=21.8, wh_big_ratio=BIG_LOCATOR_RATIO_LONG, ), PaperSpatialType.PST_11_S: PaperConfig( type=PaperSpatialType.PST_11_S, block_items=BlockItems.BI_11, locator_type=BigLocatorType.BLT_SHORT, items_num=11, slices_num=39, first_pos=2.25, step=3.5, dist_times=17.6, wh_big_ratio=BIG_LOCATOR_RATIO_SHORT, ), PaperSpatialType.PST_11_L: PaperConfig( type=PaperSpatialType.PST_11_L, block_items=BlockItems.BI_11, locator_type=BigLocatorType.BLT_LONG, items_num=11, slices_num=39, first_pos=2.25, step=3.5, dist_times=18.1, wh_big_ratio=BIG_LOCATOR_RATIO_LONG, ), PaperSpatialType.PST_8_S: PaperConfig( type=PaperSpatialType.PST_8_S, block_items=BlockItems.BI_8, locator_type=BigLocatorType.BLT_SHORT, items_num=8, slices_num=29, first_pos=2.25, step=3.5, dist_times=12.9, wh_big_ratio=BIG_LOCATOR_RATIO_SHORT, ), PaperSpatialType.PST_8_L: PaperConfig( type=PaperSpatialType.PST_8_L, block_items=BlockItems.BI_8, locator_type=BigLocatorType.BLT_LONG, items_num=8, slices_num=29, first_pos=2.25, step=3.5, dist_times=13.4, wh_big_ratio=BIG_LOCATOR_RATIO_LONG, ), } PAPER_TYPE_NAMES = { PaperSpatialType.PST_14_S: "14联(S型/10mm)", PaperSpatialType.PST_14_L: "14联(L型/15mm)", PaperSpatialType.PST_11_S: "11联(S型/10mm)", PaperSpatialType.PST_11_L: "11联(L型/15mm)", PaperSpatialType.PST_8_S: "8联(S型/10mm)", PaperSpatialType.PST_8_L: "8联(L型/15mm)", } LOCATOR_COLOR_NAMES = { LocatorColor.RED: "红色", LocatorColor.GREEN: "绿色", LocatorColor.BLUE: "蓝色", LocatorColor.UNKNOWN: "未知", } def match_paper_config(dist_ratio: float, area_ratio: float, locator_type: BigLocatorType) -> PaperSpatialType: """ 根据距离比和面积比匹配试纸规格 直接平移 C++ PaperConfigManager::matchConfig() """ # 面积比范围 Min_AreaRadio_S = 2.6 Max_AreaRadio_S = 4.0 Min_AreaRadio_L = 4.2 Max_AreaRadio_L = 6.0 # S型 (10mm) 距离比 Min_DistRadio_14S = 19.0 Max_DistRadio_14S = 26.5 Min_DistRadio_11S = 15.5 Max_DistRadio_11S = 18.5 Min_DistRadio_8S = 11.6 Max_DistRadio_8S = 14.1 # L型 (15mm) 距离比 Min_DistRadio_14L = 19.0 Max_DistRadio_14L = 26.98 Min_DistRadio_11L = 15.5 Max_DistRadio_11L = 18.5 Min_DistRadio_8L = 12.0 Max_DistRadio_8L = 14.5 # 检查面积比是否在有效范围内 if area_ratio < Min_AreaRadio_S or area_ratio > Max_AreaRadio_L: return PaperSpatialType.PST_UNKNOWN # 空白区间 [4.0, 4.2] 不做判断 if area_ratio > Max_AreaRadio_S and area_ratio < Min_AreaRadio_L: return PaperSpatialType.PST_UNKNOWN is_small_type = area_ratio <= Max_AreaRadio_S if is_small_type: if dist_ratio > Min_DistRadio_14S and dist_ratio < Max_DistRadio_14S: return PaperSpatialType.PST_14_S elif dist_ratio > Min_DistRadio_11S and dist_ratio < Max_DistRadio_11S: return PaperSpatialType.PST_11_S elif dist_ratio > Min_DistRadio_8S and dist_ratio < Max_DistRadio_8S: return PaperSpatialType.PST_8_S else: if dist_ratio > Min_DistRadio_14L and dist_ratio < Max_DistRadio_14L: return PaperSpatialType.PST_14_L elif dist_ratio > Min_DistRadio_11L and dist_ratio < Max_DistRadio_11L: return PaperSpatialType.PST_11_L elif dist_ratio > Min_DistRadio_8L and dist_ratio < Max_DistRadio_8L: return PaperSpatialType.PST_8_L return PaperSpatialType.PST_UNKNOWN # ============================================================================= # 颜色读取器 (ColorReader.h/.cpp) # ============================================================================= class ColorReader: """颜色读取器：白平衡 + 颜色采样 + 颜色空间转换""" @staticmethod def apply_white_balance(image: np.ndarray) -> np.ndarray: """灰度世界白平衡算法""" if image is None or image.size == 0: return image # 确保BGR格式 if len(image.shape) == 2: bgr = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR) elif image.shape[2] == 4: bgr = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR) else: bgr = image.copy() # 计算各通道均值 avg_b, avg_g, avg_r = cv2.mean(bgr)[:3] avg_b = max(avg_b, 1.0) avg_g = max(avg_g, 1.0) avg_r = max(avg_r, 1.0) target_avg = (avg_b + avg_g + avg_r) / 3.0 if target_avg < 1: return image b, g, r = cv2.split(bgr) b = np.clip(b * (target_avg / avg_b), 0, 255).astype(np.uint8) g = np.clip(g * (target_avg / avg_g), 0, 255).astype(np.uint8) r = np.clip(r * (target_avg / avg_r), 0, 255).astype(np.uint8) result = cv2.merge([b, g, r]) return result @staticmethod def sample_color(image: np.ndarray, center: Tuple[float, float], radius: int = DEFAULT_SAMPLE_RADIUS) -> Tuple[float, float, float]: """圆形ROI采样平均颜色，返回 (B, G, R)""" if image is None or image.size == 0: return (0.0, 0.0, 0.0) cx, cy = int(round(center[0])), int(round(center[1])) h, w = image.shape[:2] x1 = max(0, cx - radius) y1 = max(0, cy - radius) x2 = min(w - 1, cx + radius) y2 = min(h - 1, cy + radius) if x2 <= x1 or y2 <= y1: return (0.0, 0.0, 0.0) roi = image[y1:y2+1, x1:x2+1] mask = np.zeros(roi.shape[:2], dtype=np.uint8) mask_center = (cx - x1, cy - y1) cv2.circle(mask, mask_center, radius, 255, -1) avg = cv2.mean(roi, mask) return (float(avg[0]), float(avg[1]), float(avg[2])) @staticmethod def convert_color_spaces(bgr: Tuple[float, float, float]) -> dict: """BGR → RGB + HSV + LAB 转换""" b, g, r = bgr # 创建1×1像素做转换 mat = np.uint8([[[b, g, r]]]) hsv = cv2.cvtColor(mat, cv2.COLOR_BGR2HSV)[0, 0] lab = cv2.cvtColor(mat, cv2.COLOR_BGR2Lab)[0, 0] return { "r": r, "g": g, "b": b, "h": float(hsv[0]), # OpenCV H: 0-180（不转换） "s": float(hsv[1]), "v": float(hsv[2]), "l": float(lab[0]), "a": float(lab[1]), # OpenCV LAB a: 0-255（原始uint8） "b_val": float(lab[2]), # OpenCV LAB b: 0-255（原始uint8） } @classmethod def read_colors(cls, image: np.ndarray, centers: List[Tuple[float, float]], small_locator_on_left: bool, apply_wb: bool = True) -> List[ColorResult]: """读取所有色块颜色""" results = [] if image is None or not centers: return results color_image = image.copy() if apply_wb: color_image = cls.apply_white_balance(color_image) for i, center in enumerate(centers): bgr = cls.sample_color(color_image, center, DEFAULT_SAMPLE_RADIUS) cs = cls.convert_color_spaces(bgr) result = ColorResult( id=i, r=cs["r"], g=cs["g"], b=cs["b"], h=cs["h"], s=cs["s"], v=cs["v"], l=cs["l"], a=cs["a"], b_val=cs["b_val"], ) results.append(result) # 调整顺序：始终从靠近小定位块的色块开始 results = cls.adjust_order(results, small_locator_on_left) return results @staticmethod def adjust_order(colors: List[ColorResult], small_locator_on_left: bool) -> List[ColorResult]: """centers 已经是 small→big 顺序，无需反转。保留此方法供未来扩展。""" # centers 在 _calculate_color_block_centers 中已保证 # centers[0] 靠近小定位块，无需额外反转 for i in range(len(colors)): colors[i].id = i return colors # ============================================================================= # 试纸识别器 (PaperRecognizer.h/.cpp) # ============================================================================= class UrineStripRecognizer: """尿检试纸识别器 - 完整平移C++ PaperRecognizer""" def __init__(self): self.original_image: Optional[np.ndarray] = None self.process_image: Optional[np.ndarray] = None self.hsv_image: Optional[np.ndarray] = None self.gray_image: Optional[np.ndarray] = None self.locator1 = LocatorInfo() self.locator2 = LocatorInfo() self.big_locator: Optional[LocatorInfo] = None self.small_locator: Optional[LocatorInfo] = None self.has_locator1 = False self.has_locator2 = False self.centers: List[Tuple[float, float]] = [] self.config: Optional[PaperConfig] = None self.result = RecognitionResult() self.candidate_count = 0 # ===== 主入口 ===== def recognize(self, image: np.ndarray) -> RecognitionResult: """主识别函数""" self.result = RecognitionResult() logger.info("========== 开始识别 ==========") logger.info(f"图像尺寸: {image.shape[1]} x {image.shape[0]}") if image is None or image.size == 0: self.result.error_code = 7 self.result.error_message = "输入图像为空" logger.error("[错误] 输入图像为空") return self.result # Step 1: 预处理 self._preprocess_image(image) # Step 2: 检测定位块 if not self._detect_locators(): logger.error(f"[失败] 定位块检测失败, errorCode={self.result.error_code}") return self.result # Step 3: 验证定位块配对 if not self._validate_locator_pair(): logger.error(f"[失败] 定位块配对验证失败, errorCode={self.result.error_code}") return self.result # Step 3.5: 清晰度评估 big_blur, big_score = self._assess_locator_blur(self.big_locator) small_blur, small_score = self._assess_locator_blur(self.small_locator) self.result.blur_level = max(big_blur.value, small_blur.value) self.result.blur_score = min(big_score, small_score) logger.info(f"[清晰度] 大={big_score:.1f}, 小={small_score:.1f}, 等级={self.result.blur_level}") # Step 3.6: 杂物检测 paper_height = self.big_locator.height if paper_height < 30.0: self.result.error_code = 9 self.result.error_message = "试纸过小，可能为杂物" logger.error(f"[杂物检测] 试纸高度 {paper_height:.1f}px < 30px") return self.result if self.candidate_count > 15: self.result.error_code = 10 self.result.error_message = "场景过于杂乱" logger.error(f"[杂物检测] 候选数量 {self.candidate_count} > 15") return self.result # Step 4: 规格匹配 if not self._match_paper_spec(): logger.error(f"[失败] 规格匹配失败, errorCode={self.result.error_code}") return self.result # Step 5: 色块位置计算 self._calculate_color_block_centers() # Step 5.5: 生成标注图（红圈标记色块中心点） annotated_b64 = self._generate_annotated_image() # Step 6: 颜色读取 # 小定位块在左边：排序后 locator1 在左，如果 locator1 不是大定位块→小定位块在左边 small_locator_on_left = not self.locator1.is_big color_reader = ColorReader() self.result.colors = color_reader.read_colors( self.original_image, self.centers, small_locator_on_left, apply_wb=False, # 不白平衡：全图含背景会导致严重偏色 ) self.result.success = True self.result.error_code = 0 self.result.item_count = len(self.centers) self.result.annotated_image_b64 = annotated_b64 # 类型名称 self.result.paper_type_name = PAPER_TYPE_NAMES.get( self.result.paper_type, "未知") self.result.locator_color_name = LOCATOR_COLOR_NAMES.get( self.result.locator_color, "未知") logger.info(f"[成功] 识别完成! 联数={self.result.item_count}, " f"规格={self.result.paper_type_name}") logger.info("========== 识别结束 ==========") return self.result # ===== Step 1: 图像预处理 ===== def _preprocess_image(self, image: np.ndarray): """图像预处理""" self.original_image = image.copy() # 统一为BGR格式 if len(image.shape) == 2: self.process_image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR) elif image.shape[2] == 4: self.process_image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR) else: self.process_image = image.copy() # HSV和灰度 self.hsv_image = cv2.cvtColor(self.process_image, cv2.COLOR_BGR2HSV) self.gray_image = cv2.cvtColor(self.process_image, cv2.COLOR_BGR2GRAY) # 高斯滤波 self.gray_image = cv2.GaussianBlur(self.gray_image, (5, 5), 0) # ===== Step 2: 定位块检测 ===== def _detect_locators(self) -> bool: """检测定位块""" contours = self._find_candidate_contours() logger.info(f"检测到轮廓数量: {len(contours)}") if not contours: self.result.error_code = 1 self.result.error_message = "未找到轮廓" logger.error("[定位块检测] 未找到任何轮廓") return False return self._filter_locator_candidates(contours) def _find_candidate_contours(self) -> List[np.ndarray]: """查找候选轮廓: HSV颜色分割 + Canny备用""" # 策略1: HSV颜色分割 # 红色 (双范围) red_mask1 = cv2.inRange(self.hsv_image, (0, 70, 50), (10, 255, 255)) red_mask2 = cv2.inRange(self.hsv_image, (160, 70, 50), (180, 255, 255)) red_mask = cv2.bitwise_or(red_mask1, red_mask2) # 绿色 green_mask = cv2.inRange(self.hsv_image, (35, 70, 50), (85, 255, 255)) # 蓝色 (低明度，排除亮蓝绿色反应色块) blue_mask = cv2.inRange(self.hsv_image, (90, 50, 10), (150, 255, 120)) color_mask = cv2.bitwise_or(cv2.bitwise_or(red_mask, green_mask), blue_mask) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 9)) color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_CLOSE, kernel) color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_OPEN, kernel) contours, _ = cv2.findContours(color_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # 策略2: Canny边缘检测 (备用) if len(contours) < 2: edges = cv2.Canny(self.gray_image, 50, 150) edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel) contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) return list(contours) def _filter_locator_candidates(self, contours: List[np.ndarray]) -> bool: """筛选候选定位块 + Y坐标聚类 + 配对验证""" candidates: List[LocatorInfo] = [] image_area = self.original_image.shape[0] * self.original_image.shape[1] min_area = MIN_CONTOUR_AREA max_area = image_area * MAX_AREA_RATIO for contour in contours: area = cv2.contourArea(contour) # 过滤1: 面积 if area < min_area or area > max_area: continue # 最小外接旋转矩形 rotated_rect = cv2.minAreaRect(contour) w = max(rotated_rect[1]) h = min(rotated_rect[1]) aspect_ratio = w / max(h, 1.0) # 过滤2: 可能是定位块？ if not self._is_potential_locator(rotated_rect, area): continue # 过滤3: 矩形度 rect_area = rotated_rect[1][0] * rotated_rect[1][1] rectangularity = area / rect_area if rect_area > 0 else 0 if rectangularity < MIN_RECTANGULARITY: continue # 创建候选 info = LocatorInfo() info.rotated_rect = rotated_rect info.center = (rotated_rect[0][0], rotated_rect[0][1]) info.area = area info.width = w info.height = h info.color = LocatorColor.UNKNOWN # 判断大小 tolerance = 0.35 dist_big_s = abs(aspect_ratio - BIG_LOCATOR_RATIO_SHORT) dist_big_l = abs(aspect_ratio - BIG_LOCATOR_RATIO_LONG) dist_small = abs(aspect_ratio - SMALL_LOCATOR_RATIO) info.is_big = (dist_big_s < tolerance or dist_big_l < tolerance) and \ (dist_big_s < dist_small or dist_big_l < dist_small) # 过滤4: 面积范围 if info.is_big: if info.area < MIN_BIG_LOCATOR_AREA or info.area > MAX_BIG_LOCATOR_AREA: continue else: if info.area < MIN_SMALL_LOCATOR_AREA or info.area > MAX_SMALL_LOCATOR_AREA: continue candidates.append(info) if len(candidates) < 2: self.result.error_code = 1 self.result.error_message = "候选定位块数量不足" logger.error(f"[定位块检测] 候选数量不足: {len(candidates)} < 2") return False self.candidate_count = len(candidates) logger.info(f"候选定位块数量: {self.candidate_count}") # Y坐标聚类 y_groups = self._group_candidates_by_y(candidates) # 对每组尝试配对 valid_pairs = [] for i, group in enumerate(y_groups): logger.info(f"[分组配对] 尝试第 {i+1} 组, 共 {len(group)} 个候选") pair = self._find_valid_locator_pair_in_group(group) if pair is not None: valid_pairs.append(pair) # 跨组配对（处理倾斜试纸） if not valid_pairs and len(y_groups) > 1: logger.warning("[分组配对] 所有组内配对失败，尝试跨组配对") all_candidates = [] for group in y_groups: all_candidates.extend(group) pair = self._find_valid_locator_pair_in_group(all_candidates) if pair is not None: valid_pairs.append(pair) logger.info("[跨组配对] 成功找到配对!") if not valid_pairs: self.result.error_code = 2 self.result.error_message = "未找到有效定位块配对" logger.error("[定位块检测] 未找到有效配对 (需要一大一小,颜色一致,面积比正确)") return False # 多条试纸检测 if len(valid_pairs) > 1: self.result.error_code = 6 self.result.error_message = f"检测到 {len(valid_pairs)} 条试纸，请单独拍摄" logger.warning(f"[定位块检测] 检测到 {len(valid_pairs)} 条试纸") return False # 唯一有效配对 self.locator1 = valid_pairs[0][0] # big self.locator2 = valid_pairs[0][1] # small self.big_locator = self.locator1 self.small_locator = self.locator2 self.has_locator1 = True self.has_locator2 = True self._sort_locators_by_position() logger.info(f"[定位块检测成功] 大定位块颜色={self.big_locator.color.name}, " f"小定位块颜色={self.small_locator.color.name}") return True def _group_candidates_by_y(self, candidates: List[LocatorInfo]) -> List[List[LocatorInfo]]: """Y坐标聚类""" if not candidates: return [] # 按Y排序 candidates.sort(key=lambda c: c.center[1]) avg_height = sum(c.height for c in candidates) / len(candidates) y_threshold = avg_height * 3.0 groups = [] current = [candidates[0]] for i in range(1, len(candidates)): y_diff = candidates[i].center[1] - candidates[i-1].center[1] if y_diff < y_threshold: current.append(candidates[i]) else: groups.append(current) current = [candidates[i]] if current: groups.append(current) return groups def _find_valid_locator_pair_in_group(self, group: List[LocatorInfo]) \ -> Optional[Tuple[LocatorInfo, LocatorInfo]]: """在组内找有效配对，返回 (big, small) 或 None""" if len(group) < 2: return None # 按X排序 group.sort(key=lambda c: c.center[0]) for i in range(len(group)): for j in range(i + 1, len(group)): left = group[i] right = group[j] if left.is_big == right.is_big: continue big = left if left.is_big else right small = right if left.is_big else left # 延迟计算颜色 if big.color == LocatorColor.UNKNOWN: big.avg_color = self._get_center_region_color(big.rotated_rect) big.color = self._determine_locator_color_by_center(big.rotated_rect) if small.color == LocatorColor.UNKNOWN: small.avg_color = self._get_center_region_color(small.rotated_rect) small.color = self._determine_locator_color_by_center(small.rotated_rect) # 验证1: 颜色类型一致 if big.color == LocatorColor.UNKNOWN or small.color == LocatorColor.UNKNOWN: continue if big.color != small.color: continue # 验证2: RGB距离 color_dist = self._calculate_color_distance(big.avg_color, small.avg_color) if color_dist > COLOR_DISTANCE_THRESHOLD: continue # 验证3: 面积比 area_ratio = big.area / max(small.area, 1.0) error_s = abs(area_ratio - AREA_RATIO_SHORT) / AREA_RATIO_SHORT error_l = abs(area_ratio - AREA_RATIO_LONG) / AREA_RATIO_LONG area_error = min(error_s, error_l) if area_error > AREA_ERROR_RATIO: continue # 验证4: Y坐标差距 y_diff = abs(big.center[1] - small.center[1]) avg_h = (big.height + small.height) / 2.0 if y_diff > avg_h * 4.0: continue logger.info(f"[配对检测] 成功!") return (big, small) return None # ===== Step 3: 配对验证 ===== def _validate_locator_pair(self) -> bool: """验证定位块配对（颜色一致性）""" if not self.has_locator1 or not self.has_locator2: self.result.error_code = 2 self.result.error_message = "定位块未初始化" return False if self.locator1.color == LocatorColor.UNKNOWN or \ self.locator2.color == LocatorColor.UNKNOWN: self.result.error_code = 3 self.result.error_message = "定位块颜色未知" return False if self.locator1.color != self.locator2.color: self.result.error_code = 3 self.result.error_message = "定位块颜色不一致" return False color_dist = self._calculate_color_distance( self.locator1.avg_color, self.locator2.avg_color) logger.info(f"定位块颜色距离: {color_dist:.1f} (阈值: {COLOR_DISTANCE_THRESHOLD})") if color_dist > COLOR_DISTANCE_THRESHOLD: self.result.error_code = 3 self.result.error_message = "定位块颜色距离过大" return False self.result.locator_color = self.locator1.color logger.info(f"[配对验证成功] 定位块颜色: {self.result.locator_color.name}") return True # ===== Step 4: 规格匹配 ===== def _match_paper_spec(self) -> bool: """匹配试纸规格""" dx = self.locator2.center[0] - self.locator1.center[0] dy = self.locator2.center[1] - self.locator1.center[1] dist = math.sqrt(dx * dx + dy * dy) paper_height = self.big_locator.height if paper_height < 1: self.result.error_code = 4 self.result.error_message = "试纸高度无效" return False dist_ratio = dist / paper_height area_ratio = self.big_locator.area / max(self.small_locator.area, 1.0) mid_point = (AREA_RATIO_SHORT + AREA_RATIO_LONG) / 2.0 locator_type = BigLocatorType.BLT_SHORT if area_ratio < mid_point else BigLocatorType.BLT_LONG logger.info(f"--- 规格匹配参数 ---") logger.info(f"定位块中心距离: {dist:.2f}px") logger.info(f"试纸高度: {paper_height:.2f}px") logger.info(f"距离比: {dist_ratio:.3f}") logger.info(f"面积比: {area_ratio:.3f}") logger.info(f"大定位块类型: {'S型(10mm)' if locator_type == BigLocatorType.BLT_SHORT else 'L型(15mm)'}") self.result.paper_type = match_paper_config(dist_ratio, area_ratio, locator_type) if self.result.paper_type == PaperSpatialType.PST_UNKNOWN: self.result.error_code = 4 self.result.error_message = f"试纸规格未匹配 (distRatio={dist_ratio:.2f})" logger.error(f"[规格匹配失败] distRatio={dist_ratio:.2f} 不在任何规格范围内") return False self.config = PAPER_CONFIGS.get(self.result.paper_type) if self.config is None: self.result.error_code = 4 self.result.error_message = "配置未找到" return False logger.info(f"[规格匹配成功] 类型={self.result.paper_type_name}, " f"联数={self.config.items_num}") return True # ===== Step 5: 色块位置计算 ===== def _calculate_color_block_centers(self): """计算色块中心点坐标""" self.centers = [] if self.config is None or self.big_locator is None or self.small_locator is None: return # 判断小定位块位置 small_locator_on_left = not self.locator1.is_big # 方向向量 (从小定位块指向大定位块) dx = self.big_locator.center[0] - self.small_locator.center[0] dy = self.big_locator.center[1] - self.small_locator.center[1] dist = math.sqrt(dx * dx + dy * dy) if dist < 1: return unit_x = dx / dist unit_y = dy / dist big_w = self.big_locator.width small_w = self.small_locator.width # 小定位块边缘中心 (靠近大定位块一侧) small_edge_x = self.small_locator.center[0] + small_w * 0.5 * unit_x small_edge_y = self.small_locator.center[1] + small_w * 0.5 * unit_y # 大定位块边缘中心 (靠近小定位块一侧) big_edge_x = self.big_locator.center[0] - big_w * 0.5 * unit_x big_edge_y = self.big_locator.center[1] - big_w * 0.5 * unit_y effective_dx = big_edge_x - small_edge_x effective_dy = big_edge_y - small_edge_y effective_dist = math.sqrt(effective_dx * effective_dx + effective_dy * effective_dy) if effective_dist < 1: logger.error(f"[色块计算] 有效距离太小: {effective_dist:.2f}") return avg_dist = effective_dist / self.config.slices_num first_offset = avg_dist * self.config.first_pos step_offset = avg_dist * self.config.step logger.info(f"[色块计算] effectiveDist={effective_dist:.2f}, " f"slicesNum={self.config.slices_num}, " f"firstOffset={first_offset:.2f}, stepOffset={step_offset:.2f}") for i in range(self.config.items_num): offset = first_offset + step_offset * i cx = small_edge_x + offset * unit_x cy = small_edge_y + offset * unit_y self.centers.append((cx, cy)) logger.info(f"[色块计算] 成功计算 {len(self.centers)} 个色块中心") # ===== Step 5.5: 生成标注图 ===== def _generate_annotated_image(self) -> str: """生成标注图（红圈标记色块中心点），返回 base64 编码的 JPEG""" import base64 if self.original_image is None or not self.centers: return "" # 克隆原图 annotated = self.original_image.copy() # 确保 BGR 格式 if len(annotated.shape) == 2: annotated = cv2.cvtColor(annotated, cv2.COLOR_GRAY2BGR) elif annotated.shape[2] == 4: annotated = cv2.cvtColor(annotated, cv2.COLOR_BGRA2BGR) # 绘制色块中心红圈（C++ PaperRecognizer::drawAnnotations） for cx, cy in self.centers: cv2.circle(annotated, (int(cx), int(cy)), 6, (0, 0, 255), 2) # 编码为 JPEG base64 _, buf = cv2.imencode('.jpg', annotated, [cv2.IMWRITE_JPEG_QUALITY, 85]) b64 = base64.b64encode(buf).decode('utf-8') return b64 # ===== 辅助函数 ===== def _is_potential_locator(self, rect: cv2.RotatedRect, area: float) -> bool: """检查是否是潜在的定位块""" w = max(rect[1]) h = min(rect[1]) aspect_ratio = w / max(h, 1.0) # 排除正方形 if 0.9 <= aspect_ratio <= 1.1: return False # 排除过长形状 if aspect_ratio > 4.0: return False # 检查宽高比范围 tolerance = 0.35 is_big = (abs(aspect_ratio - BIG_LOCATOR_RATIO_SHORT) < tolerance or abs(aspect_ratio - BIG_LOCATOR_RATIO_LONG) < tolerance) is_small = abs(aspect_ratio - SMALL_LOCATOR_RATIO) < tolerance return is_big or is_small def _sort_locators_by_position(self): """按X坐标排序，locator1在左，locator2在右""" if self.locator1.center[0] > self.locator2.center[0]: # 交换两个定位块 self.locator1, self.locator2 = self.locator2, self.locator1 # 重新确定大/小定位块引用 self.big_locator = self.locator1 if self.locator1.is_big else self.locator2 self.small_locator = self.locator2 if self.locator1.is_big else self.locator1 def _calculate_color_distance(self, c1: Tuple[float, float, float], c2: Tuple[float, float, float]) -> float: """RGB欧氏距离""" db = c1[0] - c2[0] dg = c1[1] - c2[1] dr = c1[2] - c2[2] return math.sqrt(dr * dr + dg * dg + db * db) def _get_center_region_color(self, rect: cv2.RotatedRect) -> Tuple[float, float, float]: """获取旋转矩形中心30%区域的平均颜色""" new_size = (rect[1][0] * 0.3, rect[1][1] * 0.3) center_rect = (rect[0], new_size, rect[2]) roi = cv2.boxPoints(center_rect).astype(np.int32) # 使用boundingRect近似 x, y, w, h = cv2.boundingRect(roi) x = max(0, x); y = max(0, y) w = min(w, self.process_image.shape[1] - x) h = min(h, self.process_image.shape[0] - y) if w <= 0 or h <= 0: return (0.0, 0.0, 0.0) roi_mat = self.process_image[y:y+h, x:x+w] avg = cv2.mean(roi_mat) return (float(avg[0]), float(avg[1]), float(avg[2])) def _determine_locator_color_by_center(self, rect: cv2.RotatedRect) -> LocatorColor: """通过中心区域颜色判断定位块颜色""" avg = self._get_center_region_color(rect) b, g, r = avg blue_margin = 15.0 other_margin = 15.0 # RGB策略 if b > g + blue_margin and b > r + blue_margin: return LocatorColor.BLUE if g > b + other_margin and g > r + other_margin: return LocatorColor.GREEN if r > g + other_margin and r > b + other_margin: return LocatorColor.RED # HSV策略 x, y, w, h = cv2.boundingRect(cv2.boxPoints(rect).astype(np.int32)) x = max(0, x); y = max(0, y) w = min(w, self.hsv_image.shape[1] - x) h = min(h, self.hsv_image.shape[0] - y) if w > 0 and h > 0: # 取中心小区域 cx, cy = x + w // 2, y + h // 2 cw, ch = int(w * 0.3), int(h * 0.3) cx1 = max(0, cx - cw // 2) cy1 = max(0, cy - ch // 2) cx2 = min(self.hsv_image.shape[1], cx1 + cw) cy2 = min(self.hsv_image.shape[0], cy1 + ch) if cx2 > cx1 and cy2 > cy1: roi_hsv = self.hsv_image[cy1:cy2, cx1:cx2] avg_hsv = cv2.mean(roi_hsv) hue, sat = avg_hsv[0], avg_hsv[1] if hue >= 95 and hue < 130 and sat > 50: return LocatorColor.BLUE if hue > 35 and hue < 85 and sat > 50: return LocatorColor.GREEN if (hue < 25 or hue > 150) and sat > 50: return LocatorColor.RED return LocatorColor.UNKNOWN def _assess_locator_blur(self, locator: LocatorInfo) -> Tuple[BlurLevel, float]: """评估定位块区域清晰度 (Laplacian方差法)""" rect = locator.rotated_rect w, h = rect[1] expand = 0.15 x = int(rect[0][0] - w / 2 - w * expand) y = int(rect[0][1] - h / 2 - h * expand) rw = int(w + 2 * w * expand) rh = int(h + 2 * h * expand) x = max(0, x); y = max(0, y) rw = min(rw, self.gray_image.shape[1] - x) rh = min(rh, self.gray_image.shape[0] - y) if rw <= 0 or rh <= 0: return BlurLevel.BLUR_SEVERE, 0.0 roi = self.gray_image[y:y+rh, x:x+rw] laplacian = cv2.Laplacian(roi, cv2.CV_64F) _, stddev = cv2.meanStdDev(laplacian) score = float(stddev[0][0] * stddev[0][0]) if score > 300: return BlurLevel.BLUR_NONE, score elif score > 100: return BlurLevel.BLUR_SLIGHT, score else: return BlurLevel.BLUR_SEVERE, score # ============================================================================= # 便捷函数 # ============================================================================= def analyze_urine_strip(image_data: bytes) -> dict: """ 完整分析流程: bytes → 识别 → JSON结果 用于API路由调用 """ # 解码图片 nparr = np.frombuffer(image_data, np.uint8) image = cv2.imdecode(nparr, cv2.IMREAD_COLOR) if image is None: return { "success": False, "error_code": 7, "error_message": "无法解码图片", } # 识别 recognizer = UrineStripRecognizer() result = recognizer.recognize(image) # 构建响应 item_names = ITEM_NAMES_MAP.get(result.item_count, []) colors_output = [] for cr in result.colors: item = { "id": cr.id, "rgb": {"r": round(cr.r, 1), "g": round(cr.g, 1), "b": round(cr.b, 1)}, "hsv": {"h": round(cr.h, 1), "s": round(cr.s, 1), "v": round(cr.v, 1)}, "lab": {"l": round(cr.l, 1), "a": round(cr.a, 1), "b": round(cr.b_val, 1)}, } if cr.id < len(item_names): item["name"] = item_names[cr.id] colors_output.append(item) return { "success": result.success, "error_code": result.error_code, "error_message": result.error_message, "paper_type": result.paper_type_name, "locator_color": result.locator_color_name, "item_count": result.item_count, "blur_level": result.blur_level, "blur_score": round(result.blur_score, 1), "annotated_image_base64": result.annotated_image_b64, "colors": colors_output, }