From 704b20cde1db5e6e4b61974ca5fc675a2b8134b0 Mon Sep 17 00:00:00 2001 From: gcw_4spBpAfv Date: Tue, 24 Mar 2026 10:18:48 +0800 Subject: [PATCH] add ArUco but no activated --- app.yaml | 2 +- aruco_detector.py | 420 +++++++++++++++++++++++++ config.py | 38 ++- laser_manager.py | 97 +++++- network.py | 1 - test/test_cammera.py | 17 + test/test_decect_circle.py | 620 +++++++++++++++++++++++++++++++++++++ test/test_laser.py | 172 ++++++++++ vision.py | 33 ++ 9 files changed, 1394 insertions(+), 6 deletions(-) create mode 100644 aruco_detector.py create mode 100644 test/test_cammera.py create mode 100644 test/test_decect_circle.py create mode 100644 test/test_laser.py diff --git a/app.yaml b/app.yaml index d7dbbac..2b48e71 100644 --- a/app.yaml +++ b/app.yaml @@ -1,6 +1,6 @@ id: t11 name: t11 -version: 1.2.9 +version: 1.2.10 author: t11 icon: '' desc: t11 diff --git a/aruco_detector.py b/aruco_detector.py new file mode 100644 index 0000000..1b8b464 --- /dev/null +++ b/aruco_detector.py @@ -0,0 +1,420 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +ArUco标记检测模块 +提供基于ArUco标记的靶心标定和激光点定位功能 +""" +import cv2 +import numpy as np +import math +import config +from logger_manager import logger_manager + + +class ArUcoDetector: + """ArUco标记检测器""" + + def __init__(self): + self.logger = logger_manager.logger + # 创建ArUco字典和检测器参数 + self.aruco_dict = cv2.aruco.getPredefinedDictionary(config.ARUCO_DICT_TYPE) + self.detector_params = cv2.aruco.DetectorParameters() + + # 设置检测参数 + self.detector_params.minMarkerPerimeterRate = config.ARUCO_MIN_MARKER_PERIMETER_RATE + self.detector_params.cornerRefinementMethod = config.ARUCO_CORNER_REFINEMENT_METHOD + + # 创建检测器 + self.detector = cv2.aruco.ArucoDetector(self.aruco_dict, self.detector_params) + + # 预定义靶纸上的标记位置（物理坐标，毫米） + self.marker_positions_mm = config.ARUCO_MARKER_POSITIONS_MM + self.marker_ids = config.ARUCO_MARKER_IDS + self.marker_size_mm = config.ARUCO_MARKER_SIZE_MM + self.target_paper_size_mm = config.TARGET_PAPER_SIZE_MM + + # 靶心偏移（相对于靶纸中心） + self.target_center_offset_mm = config.TARGET_CENTER_OFFSET_MM + + if self.logger: + self.logger.info(f"[ARUCO] ArUco检测器初始化完成，字典类型: {config.ARUCO_DICT_TYPE}") + + def detect_markers(self, frame): + """ + 检测图像中的ArUco标记 + + Args: + frame: MaixPy图像帧对象 + + Returns: + (corners, ids, rejected) - 检测到的标记角点、ID列表、被拒绝的候选 + 如果检测失败返回 (None, None, None) + """ + try: + # 转换为OpenCV格式 + from maix import image + img_cv = image.image2cv(frame, False, False) + + # 转换为灰度图（ArUco检测需要） + if len(img_cv.shape) == 3: + gray = cv2.cvtColor(img_cv, cv2.COLOR_RGB2GRAY) + else: + gray = img_cv + + # 检测标记 + corners, ids, rejected = self.detector.detectMarkers(gray) + + if self.logger and ids is not None: + self.logger.debug(f"[ARUCO] 检测到 {len(ids)} 个标记: {ids.flatten().tolist()}") + + return corners, ids, rejected + + except Exception as e: + if self.logger: + self.logger.error(f"[ARUCO] 标记检测失败: {e}") + return None, None, None + + def get_target_center_from_markers(self, corners, ids): + """ + 从检测到的ArUco标记计算靶心位置 + + Args: + corners: 标记角点列表 + ids: 标记ID列表 + + Returns: + (center_x, center_y, radius, ellipse_params) 或 (None, None, None, None) + center_x, center_y: 靶心像素坐标 + radius: 估计的靶心半径（像素） + ellipse_params: 椭圆参数用于透视校正 + """ + if ids is None or len(ids) < 3: + if self.logger: + self.logger.debug(f"[ARUCO] 检测到的标记数量不足: {len(ids) if ids is not None else 0} < 3") + return None, None, None, None + + try: + # 将ID转换为列表便于查找 + detected_ids = ids.flatten().tolist() + + # 收集检测到的标记中心点和对应的物理坐标 + image_points = [] # 图像坐标 (像素) + object_points = [] # 物理坐标 (毫米) + marker_centers = {} # 存储每个标记的中心 + + for i, marker_id in enumerate(detected_ids): + if marker_id not in self.marker_ids: + continue + + # 计算标记中心（四个角的平均值） + corner = corners[i][0] # shape: (4, 2) + center_x = np.mean(corner[:, 0]) + center_y = np.mean(corner[:, 1]) + marker_centers[marker_id] = (center_x, center_y) + + # 添加到点列表 + image_points.append([center_x, center_y]) + object_points.append(self.marker_positions_mm[marker_id]) + + if len(image_points) < 3: + if self.logger: + self.logger.debug(f"[ARUCO] 有效标记数量不足: {len(image_points)} < 3") + return None, None, None, None + + # 转换为numpy数组 + image_points = np.array(image_points, dtype=np.float32) + object_points = np.array(object_points, dtype=np.float32) + + # 计算单应性矩阵（Homography） + # 这建立了物理坐标到图像坐标的映射 + H, status = cv2.findHomography(object_points, image_points, cv2.RANSAC, 5.0) + + if H is None: + if self.logger: + self.logger.warning("[ARUCO] 无法计算单应性矩阵") + return None, None, None, None + + # 计算靶心在图像中的位置 + # 靶心物理坐标 = 靶纸中心 + 偏移 + target_center_mm = np.array([[self.target_center_offset_mm[0], + self.target_center_offset_mm[1]]], dtype=np.float32) + target_center_mm = target_center_mm.reshape(-1, 1, 2) + + # 使用单应性矩阵投影到图像坐标 + target_center_img = cv2.perspectiveTransform(target_center_mm, H) + center_x = target_center_img[0][0][0] + center_y = target_center_img[0][0][1] + + # 计算靶心半径（像素） + # 使用已知物理距离和像素距离的比例 + # 选择两个标记计算比例尺 + if len(marker_centers) >= 2: + # 使用对角线上的标记计算比例尺 + if 0 in marker_centers and 2 in marker_centers: + p1_img = np.array(marker_centers[0]) + p2_img = np.array(marker_centers[2]) + p1_mm = np.array(self.marker_positions_mm[0]) + p2_mm = np.array(self.marker_positions_mm[2]) + elif 1 in marker_centers and 3 in marker_centers: + p1_img = np.array(marker_centers[1]) + p2_img = np.array(marker_centers[3]) + p1_mm = np.array(self.marker_positions_mm[1]) + p2_mm = np.array(self.marker_positions_mm[3]) + else: + # 使用任意两个标记 + keys = list(marker_centers.keys()) + p1_img = np.array(marker_centers[keys[0]]) + p2_img = np.array(marker_centers[keys[1]]) + p1_mm = np.array(self.marker_positions_mm[keys[0]]) + p2_mm = np.array(self.marker_positions_mm[keys[1]]) + + pixel_distance = np.linalg.norm(p1_img - p2_img) + mm_distance = np.linalg.norm(p1_mm - p2_mm) + + if mm_distance > 0: + pixels_per_mm = pixel_distance / mm_distance + # 标准靶心半径：10环半径约1.22cm = 12.2mm + # 但这里我们返回一个估计值，实际环数计算在laser_manager中 + radius_mm = 122.0 # 整个靶纸的半径约200mm，但靶心区域较小 + radius = int(radius_mm * pixels_per_mm) + else: + radius = 100 # 默认值 + else: + radius = 100 # 默认值 + + # 计算椭圆参数（用于透视校正） + # 从单应性矩阵可以推导出透视变形 + ellipse_params = self._compute_ellipse_params(H, center_x, center_y) + + if self.logger: + self.logger.info(f"[ARUCO] 靶心计算成功: 中心=({center_x:.1f}, {center_y:.1f}), " + f"半径={radius}px, 检测到{len(marker_centers)}个标记") + + return (int(center_x), int(center_y)), radius, "aruco", ellipse_params + + except Exception as e: + if self.logger: + self.logger.error(f"[ARUCO] 计算靶心失败: {e}") + import traceback + self.logger.error(traceback.format_exc()) + return None, None, None, None + + def _compute_ellipse_params(self, H, center_x, center_y): + """ + 从单应性矩阵计算椭圆参数，用于透视校正 + + Args: + H: 单应性矩阵 (3x3) + center_x, center_y: 靶心图像坐标 + + Returns: + ellipse_params: ((center_x, center_y), (width, height), angle) + """ + try: + # 在物理坐标系中画一个圆，投影到图像中看变成什么形状 + # 物理圆：半径10mm + r_mm = 10.0 + angles = np.linspace(0, 2*np.pi, 16) + circle_mm = np.array([[self.target_center_offset_mm[0] + r_mm * np.cos(a), + self.target_center_offset_mm[1] + r_mm * np.sin(a)] + for a in angles], dtype=np.float32) + circle_mm = circle_mm.reshape(-1, 1, 2) + + # 投影到图像 + circle_img = cv2.perspectiveTransform(circle_mm, H) + circle_img = circle_img.reshape(-1, 2) + + # 拟合椭圆 + if len(circle_img) >= 5: + ellipse = cv2.fitEllipse(circle_img.astype(np.float32)) + return ellipse + else: + # 从单应性矩阵近似估计 + # 提取缩放和旋转 + # H = K * [R|t] 的近似 + # 这里简化处理：假设没有严重变形 + scale_x = np.linalg.norm(H[0, :2]) + scale_y = np.linalg.norm(H[1, :2]) + avg_scale = (scale_x + scale_y) / 2 + + width = r_mm * 2 * scale_x + height = r_mm * 2 * scale_y + angle = np.degrees(np.arctan2(H[1, 0], H[0, 0])) + + return ((center_x, center_y), (width, height), angle) + + except Exception as e: + if self.logger: + self.logger.debug(f"[ARUCO] 计算椭圆参数失败: {e}") + return None + + def transform_laser_point(self, laser_point, corners, ids): + """ + 将激光点从图像坐标转换到物理坐标（毫米），再计算相对于靶心的偏移 + + Args: + laser_point: (x, y) 激光点在图像中的坐标 + corners: 检测到的标记角点 + ids: 检测到的标记ID + + Returns: + (dx_mm, dy_mm) 激光点相对于靶心的偏移（毫米），或 (None, None) + """ + if laser_point is None or ids is None or len(ids) < 3: + return None, None + + try: + # 重新计算单应性矩阵（可以优化为缓存） + detected_ids = ids.flatten().tolist() + image_points = [] + object_points = [] + + for i, marker_id in enumerate(detected_ids): + if marker_id not in self.marker_ids: + continue + corner = corners[i][0] + center_x = np.mean(corner[:, 0]) + center_y = np.mean(corner[:, 1]) + image_points.append([center_x, center_y]) + object_points.append(self.marker_positions_mm[marker_id]) + + if len(image_points) < 3: + return None, None + + image_points = np.array(image_points, dtype=np.float32) + object_points = np.array(object_points, dtype=np.float32) + + H, _ = cv2.findHomography(object_points, image_points, cv2.RANSAC, 5.0) + if H is None: + return None, None + + # 求逆矩阵，将图像坐标转换到物理坐标 + H_inv = np.linalg.inv(H) + + laser_img = np.array([[laser_point[0], laser_point[1]]], dtype=np.float32) + laser_img = laser_img.reshape(-1, 1, 2) + + laser_mm = cv2.perspectiveTransform(laser_img, H_inv) + laser_x_mm = laser_mm[0][0][0] + laser_y_mm = laser_mm[0][0][1] + + # 计算相对于靶心的偏移 + # 注意：Y轴方向可能需要翻转（图像Y向下，物理Y通常向上） + dx_mm = laser_x_mm - self.target_center_offset_mm[0] + dy_mm = -(laser_y_mm - self.target_center_offset_mm[1]) # 翻转Y轴 + + if self.logger: + self.logger.debug(f"[ARUCO] 激光点转换: 图像({laser_point[0]:.1f}, {laser_point[1]:.1f}) -> " + f"物理({laser_x_mm:.1f}, {laser_y_mm:.1f}) -> " + f"偏移({dx_mm:.1f}, {dy_mm:.1f})mm") + + return dx_mm, dy_mm + + except Exception as e: + if self.logger: + self.logger.error(f"[ARUCO] 激光点转换失败: {e}") + return None, None + + def draw_debug_info(self, frame, corners, ids, target_center=None, laser_point=None): + """ + 在图像上绘制调试信息 + + Args: + frame: MaixPy图像帧 + corners: 标记角点 + ids: 标记ID + target_center: 计算的靶心位置 + laser_point: 激光点位置 + + Returns: + 绘制后的图像 + """ + try: + from maix import image + img_cv = image.image2cv(frame, False, False).copy() + + # 绘制检测到的标记 + if ids is not None: + cv2.aruco.drawDetectedMarkers(img_cv, corners, ids) + + # 绘制标记ID和中心 + for i, marker_id in enumerate(ids.flatten()): + corner = corners[i][0] + center_x = int(np.mean(corner[:, 0])) + center_y = int(np.mean(corner[:, 1])) + + # 绘制中心点 + cv2.circle(img_cv, (center_x, center_y), 5, (0, 255, 0), -1) + + # 绘制ID + cv2.putText(img_cv, f"ID:{marker_id}", + (center_x + 10, center_y - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2) + + # 绘制靶心 + if target_center: + cv2.circle(img_cv, target_center, 8, (255, 0, 0), -1) + cv2.circle(img_cv, target_center, 50, (255, 0, 0), 2) + cv2.putText(img_cv, "TARGET", (target_center[0] + 15, target_center[1] - 15), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2) + + # 绘制激光点 + if laser_point: + cv2.circle(img_cv, (int(laser_point[0]), int(laser_point[1])), 6, (0, 0, 255), -1) + cv2.putText(img_cv, "LASER", (int(laser_point[0]) + 10, int(laser_point[1]) - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2) + + # 转换回MaixPy图像 + return image.cv2image(img_cv, False, False) + + except Exception as e: + if self.logger: + self.logger.error(f"[ARUCO] 绘制调试信息失败: {e}") + return frame + + +# 创建全局单例实例 +aruco_detector = ArUcoDetector() + + +def detect_target_with_aruco(frame, laser_point=None): + """ + 使用ArUco标记检测靶心的便捷函数 + + Args: + frame: MaixPy图像帧 + laser_point: 激光点坐标（可选） + + Returns: + (result_img, center, radius, method, best_radius1, ellipse_params) + 与detect_circle_v3保持相同的返回格式 + """ + detector = aruco_detector + + # 检测ArUco标记 + corners, ids, rejected = detector.detect_markers(frame) + + # 计算靶心 + center, radius, method, ellipse_params = detector.get_target_center_from_markers(corners, ids) + + # 绘制调试信息 + result_img = detector.draw_debug_info(frame, corners, ids, center, laser_point) + + # 返回与detect_circle_v3相同的格式 + # best_radius1用于距离估算，这里用radius代替 + return result_img, center, radius, method, radius, ellipse_params + + +def compute_laser_offset_aruco(laser_point, corners, ids): + """ + 使用ArUco计算激光点相对于靶心的偏移（毫米） + + Args: + laser_point: (x, y) 激光点图像坐标 + corners: ArUco标记角点 + ids: ArUco标记ID + + Returns: + (dx_mm, dy_mm) 偏移量（毫米），或 (None, None) + """ + return aruco_detector.transform_laser_point(laser_point, corners, ids) diff --git a/config.py b/config.py index 021b979..1b2de48 100644 --- a/config.py +++ b/config.py @@ -117,7 +117,7 @@ SAVE_IMAGE_ENABLED = True # 是否保存图像（True=保存，False=不保存 PHOTO_DIR = "/root/phot" # 照片存储目录 MAX_IMAGES = 1000 -SHOW_CAMERA_PHOTO_WHILE_SHOOTING = True # 是否在拍摄时显示摄像头图像（True=显示，False=不显示），建议在连着USB测试过程中打开 +SHOW_CAMERA_PHOTO_WHILE_SHOOTING = False # 是否在拍摄时显示摄像头图像（True=显示，False=不显示），建议在连着USB测试过程中打开 # ==================== OTA配置 ==================== MAX_BACKUPS = 5 @@ -149,6 +149,42 @@ PIN_MAPPINGS_WITH_WIFI = { # 根据WiFi模块开关选择引脚映射 PIN_MAPPINGS = PIN_MAPPINGS_WITH_WIFI if HAS_WIFI_MODULE else PIN_MAPPINGS_NO_WIFI +# ==================== ArUco标定配置 ==================== +USE_ARUCO = False # 是否使用ArUco标定（True=使用ArUco，False=使用传统黄色靶心检测） + +# ArUco标记配置 +if USE_ARUCO: + import cv2 + ARUCO_DICT_TYPE = cv2.aruco.DICT_4X4_50 # ArUco字典类型 + ARUCO_MARKER_SIZE_MM = 40 # ArUco标记边长（毫米） + ARUCO_MARKER_IDS = [0, 1, 2, 3] # 四个角的ArUco标记ID + + # 靶纸物理尺寸（毫米） + TARGET_PAPER_SIZE_MM = 400 # 靶纸边长 400mm x 400mm + + # ArUco标记在靶纸上的中心坐标（毫米，以靶纸中心为原点） + # 靶纸坐标系：中心(0,0)，X向右，Y向下（图像坐标系） + # 四个角位置：(20,20), (20,380), (380,380), (380,20) + # 转换为以中心为原点的坐标： + # 左上角(0): (-180, -180) -> 实际(20,20)相对于中心(200,200) = (-180,-180) + # 右上角(1): (180, -180) -> 实际(380,20)相对于中心 = (180,-180) + # 右下角(2): (180, 180) -> 实际(380,380)相对于中心 = (180,180) + # 左下角(3): (-180, 180) -> 实际(20,380)相对于中心 = (-180,180) + ARUCO_MARKER_POSITIONS_MM = { + 0: (-180, -180), # 左上角 + 1: (180, -180), # 右上角 + 2: (180, 180), # 右下角 + 3: (-180, 180), # 左下角 + } + + # 靶心（黄心）在靶纸上的位置（毫米，相对于靶纸中心） + # 标准靶纸靶心就在正中心 + TARGET_CENTER_OFFSET_MM = (0, 0) + + # ArUco检测参数 + ARUCO_MIN_MARKER_PERIMETER_RATE = 0.03 # 最小标记周长比例（相对于图像） + ARUCO_CORNER_REFINEMENT_METHOD = cv2.aruco.CORNER_REFINE_SUBPIX # 角点精修方法 + # ==================== 电源配置 ==================== AUTO_POWER_OFF_IN_SECONDS = 10 * 60 # 自动关机时间（秒），0表示不自动关机 diff --git a/laser_manager.py b/laser_manager.py index d8171ec..4d0ac99 100644 --- a/laser_manager.py +++ b/laser_manager.py @@ -8,7 +8,7 @@ import _thread import json import os import binascii -from maix import time, camera +from maix import time import threading import config from logger_manager import logger_manager @@ -861,7 +861,8 @@ class LaserManager: center_temp = None radius_temp = None if config.LASER_REQUIRE_IN_ELLIPSE: - result_img_temp, center_temp, radius_temp, method_temp, best_radius1_temp, ellipse_params_temp = vision.detect_circle_v3(frame, None) + # 使用统一的检测接口（支持ArUco和传统方法） + result_img_temp, center_temp, radius_temp, method_temp, best_radius1_temp, ellipse_params_temp = vision.detect_target(frame, None) # 只有检测到靶心时才继续处理激光点 if center_temp is None or radius_temp is None: @@ -1114,7 +1115,7 @@ class LaserManager: return self._laser_point is not None - def compute_laser_position(self, circle_center, laser_point, radius, method): + def compute_laser_position(self, circle_center, laser_point, radius, method, ellipse_params=None): """计算激光相对于靶心的偏移量（单位：厘米） Args: @@ -1122,6 +1123,7 @@ class LaserManager: laser_point: 激光点坐标 (x, y) radius: 靶心半径（像素） method: 检测方法（"模糊" 或其他） + ellipse_params: 椭圆参数，用于透视校正（可选） Returns: (dx, dy): 激光相对于靶心的偏移量（厘米），如果输入无效则返回 (None, None) @@ -1131,6 +1133,14 @@ class LaserManager: cx, cy = circle_center lx, ly = laser_point + + # 如果有椭圆参数，使用透视校正计算 + if ellipse_params is not None and method != "aruco": + return self._compute_with_perspective_correction( + circle_center, laser_point, radius, ellipse_params + ) + + # 传统计算方法 # r = 22.16 * 5 r = radius * 5 self.logger.debug(f"compute_laser_position: circle_center: {circle_center} laser_point: {laser_point} radius: {radius} method: {method} r: {r}") @@ -1138,6 +1148,87 @@ class LaserManager: target_y = (ly-cy)/r*100 self.logger.info(f"lx：{lx} ly: {ly} cx: {cx} cy: {cy} result_x: {target_x} result_y: {-target_y} real_r_x: {lx-cx} real_r_y: {-1*(ly-cy)}") return (target_x, -target_y) + + def _compute_with_perspective_correction(self, circle_center, laser_point, radius, ellipse_params): + """ + 使用透视校正计算激光偏移 + + 当相机不正对靶子时，圆会变成椭圆。使用椭圆参数进行透视校正， + 将图像坐标转换到物理坐标系，再计算偏移。 + + Args: + circle_center: 靶心中心坐标 (x, y) + laser_point: 激光点坐标 (x, y) + radius: 靶心半径（像素） + ellipse_params: ((center_x, center_y), (width, height), angle) + + Returns: + (dx, dy): 校正后的偏移量（厘米） + """ + import math + + try: + (ex, ey), (width, height), angle = ellipse_params + cx, cy = circle_center + lx, ly = laser_point + + # 步骤1: 平移到椭圆中心 + dx1 = lx - cx + dy1 = ly - cy + + # 步骤2: 旋转坐标系，使椭圆轴与坐标轴对齐 + angle_rad = math.radians(-angle) + cos_a = math.cos(angle_rad) + sin_a = math.sin(angle_rad) + + x_rot = dx1 * cos_a - dy1 * sin_a + y_rot = dx1 * sin_a + dy1 * cos_a + + # 步骤3: 归一化到单位圆 + # 椭圆半轴 + a = width / 2.0 + b = height / 2.0 + + # 归一化坐标 + if a > 0 and b > 0: + x_norm = x_rot / a + y_norm = y_rot / b + else: + x_norm = x_rot + y_norm = y_rot + + # 步骤4: 计算物理距离 + # 使用平均半径作为参考 + avg_radius = (a + b) / 2.0 + pixels_per_cm = avg_radius / 20.0 # 假设靶心半径20cm对应avg_radius像素 + + if pixels_per_cm > 0: + # 归一化距离（单位：靶心半径的倍数） + norm_distance = math.sqrt(x_norm**2 + y_norm**2) + # 转换为厘米（假设靶心半径20cm） + distance_cm = norm_distance * 20.0 + + # 计算方向 + angle_offset = math.atan2(y_norm, x_norm) + + dx_cm = distance_cm * math.cos(angle_offset) + dy_cm = -distance_cm * math.sin(angle_offset) # Y轴翻转 + + self.logger.debug(f"[PERSPECTIVE] 原始偏移: ({dx1:.1f}, {dy1:.1f})px, " + f"校正后: ({dx_cm:.2f}, {dy_cm:.2f})cm, " + f"椭圆: ({width:.1f}, {height:.1f}), 角度: {angle:.1f}°") + + return (dx_cm, dy_cm) + else: + # 回退到直接计算 + r = radius * 5 + return ((lx-cx)/r*100, -(ly-cy)/r*100) + + except Exception as e: + self.logger.error(f"[PERSPECTIVE] 透视校正计算失败: {e}") + # 回退到直接计算 + r = radius * 5 + return ((lx-cx)/r*100, -(ly-cy)/r*100) # # 根据检测方法动态调整靶心物理半径（简化模型） # circle_r = (radius / 4.0) * 20.0 if method == "模糊" else (68 / 16.0) * 20.0 diff --git a/network.py b/network.py index b1c0ebc..dd8a4a3 100644 --- a/network.py +++ b/network.py @@ -1073,7 +1073,6 @@ class NetworkManager: def tcp_main(self): """TCP 主通信循环：登录、心跳、处理指令、发送数据""" import _thread - from maix import camera self.logger.info("[NET] TCP主线程启动") diff --git a/test/test_cammera.py b/test/test_cammera.py new file mode 100644 index 0000000..f28eb14 --- /dev/null +++ b/test/test_cammera.py @@ -0,0 +1,17 @@ +# test_camera.py +from maix import camera, display, time + +try: + print("Initializing camera...") + cam = camera.Camera(640, 480) + print("Camera initialized successfully!") + + disp = display.Display() + + while True: + frame = cam.read() + disp.show(frame) + time.sleep_ms(50) + +except Exception as e: + print(f"Error: {e}") \ No newline at end of file diff --git a/test/test_decect_circle.py b/test/test_decect_circle.py new file mode 100644 index 0000000..634e5d7 --- /dev/null +++ b/test/test_decect_circle.py @@ -0,0 +1,620 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +离线测试脚本：直接复用 detect_circle 逻辑进行测试 +运行环境：MaixPy (Sipeed MAIX) +""" +import sys +import os +# import time +from maix import image,time +import cv2 +import numpy as np + +# ==================== 全局配置 (与 test_main.py 保持一致) ==================== +REAL_RADIUS_CM = 20 # 靶心实际半径（厘米） + +# ==================== 复制的核心算法 ==================== +# 注意：这里直接复制了 detect_circle 的逻辑，避免 import main 导致的冲突 + + +def detect_circle_v3(frame, laser_point=None): + """检测图像中的靶心（优先清晰轮廓，其次黄色区域）- 返回椭圆参数版本 + 增加红色圆圈检测，验证黄色圆圈是否为真正的靶心 + 如果提供 laser_point，会选择最接近激光点的目标 + + Args: + frame: 图像帧 + laser_point: 激光点坐标 (x, y)，用于多目标场景下的目标选择 + + Returns: + (result_img, best_center, best_radius, method, best_radius1, ellipse_params) + """ + img_cv = image.image2cv(frame, False, False) + + best_center = best_radius = best_radius1 = method = None + ellipse_params = None + + # HSV 黄色掩码检测（模糊靶心） + hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV) + h, s, v = cv2.split(hsv) + + # 调整饱和度策略：稍微增强，不要过度 + s = np.clip(s * 1.1, 0, 255).astype(np.uint8) + + hsv = cv2.merge((h, s, v)) + + # 放宽 HSV 阈值范围（针对模糊图像的关键调整） + lower_yellow = np.array([7, 80, 0]) # 饱和度下限降低，捕捉淡黄色 + upper_yellow = np.array([32, 255, 255]) # 亮度上限拉满 + + mask_yellow = cv2.inRange(hsv, lower_yellow, upper_yellow) + + # 调整形态学操作 + kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + mask_yellow = cv2.morphologyEx(mask_yellow, cv2.MORPH_CLOSE, kernel) + + contours_yellow, _ = cv2.findContours(mask_yellow, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + # 存储所有有效的黄色-红色组合 + valid_targets = [] + + if contours_yellow: + for cnt_yellow in contours_yellow: + area = cv2.contourArea(cnt_yellow) + perimeter = cv2.arcLength(cnt_yellow, True) + + # 计算圆度 + if perimeter > 0: + circularity = (4 * np.pi * area) / (perimeter * perimeter) + else: + circularity = 0 + + logger = get_logger() + if area > 50 and circularity > 0.7: + if logger: + logger.info(f"[target] -> 面积:{area}, 圆度:{circularity:.2f}") + # 尝试拟合椭圆 + yellow_center = None + yellow_radius = None + yellow_ellipse = None + + if len(cnt_yellow) >= 5: + (x, y), (width, height), angle = cv2.fitEllipse(cnt_yellow) + yellow_ellipse = ((x, y), (width, height), angle) + axes_minor = min(width, height) + radius = axes_minor / 2 + yellow_center = (int(x), int(y)) + yellow_radius = int(radius) + else: + (x, y), radius = cv2.minEnclosingCircle(cnt_yellow) + yellow_center = (int(x), int(y)) + yellow_radius = int(radius) + yellow_ellipse = None + + # 如果检测到黄色圆圈，再检测红色圆圈进行验证 + if yellow_center and yellow_radius: + # HSV 红色掩码检测（红色在HSV中跨越0度，需要两个范围） + # 红色范围1: 0-10度（接近0度的红色） + lower_red1 = np.array([0, 80, 0]) + upper_red1 = np.array([10, 255, 255]) + mask_red1 = cv2.inRange(hsv, lower_red1, upper_red1) + + # 红色范围2: 170-180度（接近180度的红色） + lower_red2 = np.array([170, 80, 0]) + upper_red2 = np.array([180, 255, 255]) + mask_red2 = cv2.inRange(hsv, lower_red2, upper_red2) + + # 合并两个红色掩码 + mask_red = cv2.bitwise_or(mask_red1, mask_red2) + + # 形态学操作 + kernel_red = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + mask_red = cv2.morphologyEx(mask_red, cv2.MORPH_CLOSE, kernel_red) + + contours_red, _ = cv2.findContours(mask_red, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + found_valid_red = False + + if contours_red: + # 找到所有符合条件的红色圆圈 + for cnt_red in contours_red: + area_red = cv2.contourArea(cnt_red) + perimeter_red = cv2.arcLength(cnt_red, True) + + if perimeter_red > 0: + circularity_red = (4 * np.pi * area_red) / (perimeter_red * perimeter_red) + else: + circularity_red = 0 + + # 红色圆圈也应该有一定的圆度 + if area_red > 50 and circularity_red > 0.6: + # 计算红色圆圈的中心和半径 + if len(cnt_red) >= 5: + (x_red, y_red), (w_red, h_red), angle_red = cv2.fitEllipse(cnt_red) + radius_red = min(w_red, h_red) / 2 + red_center = (int(x_red), int(y_red)) + red_radius = int(radius_red) + else: + (x_red, y_red), radius_red = cv2.minEnclosingCircle(cnt_red) + red_center = (int(x_red), int(y_red)) + red_radius = int(radius_red) + + # 计算黄色和红色圆心的距离 + if red_center: + dx = yellow_center[0] - red_center[0] + dy = yellow_center[1] - red_center[1] + distance = np.sqrt(dx*dx + dy*dy) + + # 圆心距离阈值：应该小于黄色半径的某个倍数（比如1.5倍） + max_distance = yellow_radius * 1.5 + + # 红色圆圈应该比黄色圆圈大（外圈） + if distance < max_distance and red_radius > yellow_radius * 0.8: + found_valid_red = True + logger = get_logger() + if logger: + logger.info(f"[target] -> 找到匹配的红圈: 黄心({yellow_center}), 红心({red_center}), 距离:{distance:.1f}, 黄半径:{yellow_radius}, 红半径:{red_radius}") + + # 记录这个有效目标 + valid_targets.append({ + 'center': yellow_center, + 'radius': yellow_radius, + 'ellipse': yellow_ellipse, + 'area': area + }) + break + + if not found_valid_red: + logger = get_logger() + if logger: + logger.debug("Debug -> 未找到匹配的红色圆圈，可能是误识别") + + # 从所有有效目标中选择最佳目标 + if valid_targets: + if laser_point: + # 如果有激光点，选择最接近激光点的目标 + best_target = None + min_distance = float('inf') + for target in valid_targets: + dx = target['center'][0] - laser_point[0] + dy = target['center'][1] - laser_point[1] + distance = np.sqrt(dx*dx + dy*dy) + if distance < min_distance: + min_distance = distance + best_target = target + if best_target: + best_center = best_target['center'] + best_radius = best_target['radius'] + ellipse_params = best_target['ellipse'] + method = "v3_ellipse_red_validated_laser_selected" + best_radius1 = best_radius * 5 + else: + # 如果没有激光点，选择面积最大的目标 + best_target = max(valid_targets, key=lambda t: t['area']) + best_center = best_target['center'] + best_radius = best_target['radius'] + ellipse_params = best_target['ellipse'] + method = "v3_ellipse_red_validated" + best_radius1 = best_radius * 5 + + result_img = image.cv2image(img_cv, False, False) + return result_img, best_center, best_radius, method, best_radius1, ellipse_params + +def detect_circle(frame): + """检测图像中的靶心（优先清晰轮廓，其次黄色区域）""" + img_cv = image.image2cv(frame, False, False) + # gray = cv2.cvtColor(img_cv, cv2.COLOR_RGB2GRAY) + # blurred = cv2.GaussianBlur(gray, (5, 5), 0) + # edged = cv2.Canny(blurred, 50, 150) + # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + # ceroded = cv2.erode(cv2.dilate(edged, kernel), kernel) + + # contours, _ = cv2.findContours(ceroded, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) + # best_center = best_radius = best_radius1 = method = None + + # hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV) + # h, s, v = cv2.split(hsv) + # s = np.clip(s * 2, 0, 255).astype(np.uint8) + # hsv = cv2.merge((h, s, v)) + # lower_yellow = np.array([7, 80, 0]) + # upper_yellow = np.array([32, 255, 182]) + # mask = cv2.inRange(hsv, lower_yellow, upper_yellow) + # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + # mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) + # mask = cv2.morphologyEx(mask, cv2.MORPH_DILATE, kernel) + # contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + # if contours: + # largest = max(contours, key=cv2.contourArea) + # if cv2.contourArea(largest) > 50: + # (x, y), radius = cv2.minEnclosingCircle(largest) + # best_center = (int(x), int(y)) + # best_radius = int(radius) + # best_radius1 = radius * 5 + # method = "v2" + + # auto + # R:31 M:v2 D:2.410110127692767 + # hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV) + # h, s, v = cv2.split(hsv) + + # # 1. 增强饱和度（模糊照片需要更强的增强） + # s = np.clip(s * 2.5, 0, 255).astype(np.uint8) # 从2.0改为2.5 + + # # 2. 增强亮度（模糊照片可能偏暗） + # v = np.clip(v * 1.2, 0, 255).astype(np.uint8) # 新增：提升亮度 + + # hsv = cv2.merge((h, s, v)) + + # # 3. 放宽HSV颜色范围（特别是模糊照片） + # # 降低饱和度下限，提高亮度上限 + # lower_yellow = np.array([5, 50, 30]) # H:5-35, S:50-255, V:30-255 + # upper_yellow = np.array([35, 255, 255]) + + # mask = cv2.inRange(hsv, lower_yellow, upper_yellow) + + # # 4. 增强形态学操作（连接被分割的区域） + # kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + # kernel_large = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9)) # 更大的核 + + # # 先开运算去除噪声 + # mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel_small) + # # 多次膨胀连接区域（模糊照片需要更多膨胀） + # mask = cv2.dilate(mask, kernel_large, iterations=2) # 增加迭代次数 + # mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel_large) # 闭运算填充空洞 + + # contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + # if contours: + # largest = max(contours, key=cv2.contourArea) + # area = cv2.contourArea(largest) + # if area > 50: + # # 5. 使用面积计算等效半径（更准确） + # equivalent_radius = np.sqrt(area / np.pi) + + # # 6. 同时使用minEnclosingCircle作为备选（取较大值） + # (x, y), enclosing_radius = cv2.minEnclosingCircle(largest) + + # # 取两者中的较大值，确保不遗漏 + # radius = max(equivalent_radius, enclosing_radius) + + # best_center = (int(x), int(y)) + # best_radius = int(radius) + # best_radius1 = radius * 5 + # method = "v2" + + # codegee + # R:24 M:v2 D:3.061493895819174 + # R:22 M:v2 D:3.3644971681267077 np.clip(s * 1.1, 0, 255) + hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV) + h, s, v = cv2.split(hsv) + + # 2. 调整饱和度策略： + # 不要暴力翻倍，可以尝试稍微增强，或者使用 CLAHE 增强亮度/对比度 + # 这里我们稍微增加一点饱和度，并确保不溢出 + s = np.clip(s * 1.1, 0, 255).astype(np.uint8) + # 对亮度通道 v 也可以做一点 CLAHE 处理来增强对比度（可选） + # clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8)) + # v = clahe.apply(v) + + hsv = cv2.merge((h, s, v)) + + # 3. 放宽 HSV 阈值范围（针对模糊图像的关键调整） + # 降低 S 的下限 (80 -> 35)，提高 V 的上限 (182 -> 255) + lower_yellow = np.array([7, 80, 0]) # 饱和度下限降低，捕捉淡黄色 + upper_yellow = np.array([32, 255, 255]) # 亮度上限拉满 + + mask = cv2.inRange(hsv, lower_yellow, upper_yellow) + + # 4. 调整形态学操作 + # 去掉 MORPH_OPEN，因为它会减小面积。 + # 使用 MORPH_CLOSE (先膨胀后腐蚀) 来填充内部小黑洞，连接近邻区域 + kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel) + # 再进行一次膨胀，确保边缘被包含进来 + # mask = cv2.dilate(mask, kernel, iterations=1) + + contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + if contours: + largest = max(contours, key=cv2.contourArea) + + # 这里可以适当降低面积阈值，或者保持不变 + if cv2.contourArea(largest) > 50: + # (x, y), radius = cv2.minEnclosingCircle(largest) + # best_center = (int(x), int(y)) + # best_radius = int(radius) + + # --- 核心修改开始 --- + # 1. 尝试拟合椭圆 (需要轮廓点至少为5个) + if len(largest) >= 5: + # 返回值: ((中心x, 中心y), (长轴, 短轴), 旋转角度) + (x, y), (axes_major, axes_minor), angle = cv2.fitEllipse(largest) + + # 2. 计算半径 + # 选项A：取长短轴的平均值 (比较稳健) + # radius = (axes_major + axes_minor) / 4 + + # 选项B：直接取短轴的一半 (抗模糊最强，推荐) + radius = axes_minor / 2 + + best_center = (int(x), int(y)) + best_radius = int(radius) + method = "v2_ellipse" + else: + # 如果点太少无法拟合椭圆，降级回 minEnclosingCircle + (x, y), radius = cv2.minEnclosingCircle(largest) + best_center = (int(x), int(y)) + best_radius = int(radius) + method = "v2" + # --- 核心修改结束 --- + + # 你的后续逻辑 + best_radius1 = radius * 5 + + + # operas 4.5 + # R:25 M:v2 D:2.9554872521538527 + # hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV) + # h, s, v = cv2.split(hsv) + + # # 1. 适度增强饱和度（不要过度，否则噪声也会增强） + # s = np.clip(s * 1.5, 0, 255).astype(np.uint8) + # hsv = cv2.merge((h, s, v)) + + # # 2. 放宽 HSV 阈值范围（关键改动） + # # - 饱和度下限从 80 降到 40（捕捉淡黄色） + # # - 亮度上限从 182 提高到 255（允许更亮的黄色） + # lower_yellow = np.array([7, 40, 30]) + # upper_yellow = np.array([35, 255, 255]) + + # mask = cv2.inRange(hsv, lower_yellow, upper_yellow) + + # # 3. 调整形态学操作：用 CLOSE 替代 OPEN + # # CLOSE（先膨胀后腐蚀）：填充内部空洞，连接相邻区域 + # # OPEN（先腐蚀后膨胀）：会缩小区域，不适合模糊图像 + # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7)) # 稍大的核 + # mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel) + # mask = cv2.dilate(mask, kernel, iterations=1) # 额外膨胀，确保边缘被包含 + + # contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + # if contours: + # largest = max(contours, key=cv2.contourArea) + # if cv2.contourArea(largest) > 50: + # (x, y), radius = cv2.minEnclosingCircle(largest) + # best_center = (int(x), int(y)) + # best_radius = int(radius) + # best_radius1 = radius * 5 + # method = "v2" + + # # --- 新增：将 Mask 叠加到原图上用于调试 --- + # # 创建一个彩色掩码（红色通道为255，其他为0） + # mask_overlay = np.zeros_like(img_cv) + # mask_overlay[:, :, 2] = mask # 将掩码放在红色通道 (BGR中的R) + # + # cv2.addWeighted(img_cv, 0.6, mask_overlay, 0.4, 0, img_cv) + + result_img = image.cv2image(img_cv, False, False) + return result_img, best_center, best_radius, method, best_radius1 + + +def detect_circle_v2(frame): + """检测图像中的靶心（优先清晰轮廓，其次黄色区域）- 返回椭圆参数版本""" + global REAL_RADIUS_CM + img_cv = image.image2cv(frame, False, False) + + best_center = best_radius = best_radius1 = method = None + ellipse_params = None # 存储椭圆参数 ((x, y), (axes_major, axes_minor), angle) + + # HSV 黄色掩码检测（模糊靶心） + hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV) + h, s, v = cv2.split(hsv) + + # 调整饱和度策略：稍微增强，不要过度 + s = np.clip(s * 1.1, 0, 255).astype(np.uint8) + + hsv = cv2.merge((h, s, v)) + + # 放宽 HSV 阈值范围（针对模糊图像的关键调整） + lower_yellow = np.array([7, 80, 0]) # 饱和度下限降低，捕捉淡黄色 + upper_yellow = np.array([32, 255, 255]) # 亮度上限拉满 + + mask = cv2.inRange(hsv, lower_yellow, upper_yellow) + + # 调整形态学操作 + # 使用 MORPH_CLOSE (先膨胀后腐蚀) 来填充内部小黑洞，连接近邻区域 + kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel) + + contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + if contours: + largest = max(contours, key=cv2.contourArea) + + if cv2.contourArea(largest) > 50: + # 尝试拟合椭圆 (需要轮廓点至少为5个) + if len(largest) >= 5: + # 返回值: ((中心x, 中心y), (width, height), 旋转角度) + # 注意：width 和 height 是外接矩形的尺寸，不是长轴和短轴 + (x, y), (width, height), angle = cv2.fitEllipse(largest) + + # 保存椭圆参数（保持原始顺序，用于绘制） + ellipse_params = ((x, y), (width, height), angle) + + # 计算半径：使用较小的尺寸作为短轴 + axes_minor = min(width, height) + radius = axes_minor / 2 + + best_center = (int(x), int(y)) + best_radius = int(radius) + method = "v2_ellipse" + else: + # 如果点太少无法拟合椭圆，降级回 minEnclosingCircle + (x, y), radius = cv2.minEnclosingCircle(largest) + best_center = (int(x), int(y)) + best_radius = int(radius) + method = "v2" + ellipse_params = None # 圆形，没有椭圆参数 + + best_radius1 = radius * 5 + + result_img = image.cv2image(img_cv, False, False) + return result_img, best_center, best_radius, method, best_radius1, ellipse_params + +# ==================== 测试逻辑 ==================== + +def run_offline_test(image_path): + """读取图片，检测圆，绘制结果，保存图片""" + + # 1. 检查文件是否存在 + if not os.path.exists(image_path): + print(f"[ERROR] 找不到图片文件: {image_path}") + return + + # 2. 使用 maix.image 读取图片 (适配 MaixPy v4) + try: + # 使用 image.load 读取文件，返回 Image 对象 + img = image.load(image_path) + print(f"[INFO] 成功读取图片: {image_path} (尺寸: {img.width()}x{img.height()})") + except Exception as e: + print(f"[ERROR] 读取图片失败: {e}") + print("提示：请确认 MaixPy 版本是否为 v4，且图片路径正确。") + return + + + # 3. 调用 detect_circle_v2 函数 + print("[INFO] 正在调用 detect_circle_v2 进行检测...") + start_time = time.ticks_ms() + + result_img, center, radius, method, radius1, ellipse_params = detect_circle_v3(img) + + cost_time = time.ticks_ms() - start_time + print(f"[INFO] 检测完成，耗时: {cost_time}ms") + print(f" 结果 -> 圆心: {center}, 半径: {radius}, 方法: {method}") + if ellipse_params: + (ell_center, (width, height), angle) = ellipse_params + print(f" 椭圆 -> 中心: ({ell_center[0]:.1f}, {ell_center[1]:.1f}), 长轴: {max(width, height):.1f}, 短轴: {min(width, height):.1f}, 角度: {angle:.1f}°") + + # 4. 绘制辅助线（可选，用于调试） + if center and radius: + # 为了绘制椭圆，需要转换回 cv2 图像 + img_cv = image.image2cv(result_img, False, False) + + cx, cy = center + + # 如果有椭圆参数，绘制椭圆 + if ellipse_params: + (ell_center, (width, height), angle) = ellipse_params + cx_ell, cy_ell = int(ell_center[0]), int(ell_center[1]) + + # 确定长轴和短轴 + if width >= height: + # width 是长轴，height 是短轴 + axes_major = width + axes_minor = height + major_angle = angle # 长轴角度就是 angle + minor_angle = angle + 90 # 短轴角度 = 长轴角度 + 90度 + else: + # height 是长轴，width 是短轴 + axes_major = height + axes_minor = width + major_angle = angle + 90 # 长轴角度 = width角度 + 90度 + minor_angle = angle # 短轴角度就是 angle + + # 使用 OpenCV 绘制椭圆（绿色，线宽2） + cv2.ellipse(img_cv, + (cx_ell, cy_ell), # 中心点 + (int(width/2), int(height/2)), # 半宽、半高 + angle, # 旋转角度（OpenCV需要原始angle） + 0, 360, # 起始和结束角度 + (0, 255, 0), # 绿色 (RGB格式) + 2) # 线宽 + + # 绘制椭圆中心点（红色） + cv2.circle(img_cv, (cx_ell, cy_ell), 3, (255, 0, 0), -1) + + import math + # 绘制短轴（蓝色线条） + minor_length = axes_minor / 2 + minor_angle_rad = math.radians(minor_angle) + dx_minor = minor_length * math.cos(minor_angle_rad) + dy_minor = minor_length * math.sin(minor_angle_rad) + pt1_minor = (int(cx_ell - dx_minor), int(cy_ell - dy_minor)) + pt2_minor = (int(cx_ell + dx_minor), int(cy_ell + dy_minor)) + cv2.line(img_cv, pt1_minor, pt2_minor, (0, 0, 255), 2) # 蓝色 (RGB格式) + else: + # 如果没有椭圆参数，绘制圆形（红色） + cv2.circle(img_cv, (cx, cy), radius, (0, 0, 255), 2) + cv2.circle(img_cv, (cx, cy), 2, (0, 0, 255), -1) + + # 转换回 maix image + result_img = image.cv2image(img_cv, False, False) + + # 定义颜色对象用于文字 + try: + color_black = image.Color.from_rgb(0,0,0) + except AttributeError: + color_black = image.Color(0,0,0) + + # D. 添加文字信息 + FOCAL_LENGTH_PIX = 1900 + d = (REAL_RADIUS_CM * FOCAL_LENGTH_PIX) / radius1 / 100.0 + info_str = f"R:{radius} M:{method} D:{d:.2f}" + print(info_str) + + # 计算文字位置，防止超出图片边界 + r_outer = int(radius * 11.0) if radius else 100 + text_y = cy - r_outer - 20 if cy > r_outer + 20 else cy + r_outer + 20 + + # 调用 draw_string + result_img.draw_string(0, 0, info_str, color=color_black, scale=1.0) + + + # 5. 保存结果图片 + output_path = image_path.replace(".bmp", "_result.bmp") + output_path = image_path.replace(".jpg", "_result.jpg") + try: + result_img.save(output_path, quality=100) + print(f"[SUCCESS] 结果已保存至: {output_path}") + except Exception as e: + print(f"[ERROR] 保存图片失败: {e}") + +if __name__ == "__main__": + # ================= 配置区域 ================= + + # 1. 设置要测试的图片路径 + # 建议将图片放在与脚本同级目录，或者使用绝对路径 + TARGET_IMAGE = "/root/phot/None_314_258_0_0041.bmp" + + # TARGET_DIR = "/root/phot_test2" # 修改为你想要读取的目录路径 + + # 支持的图片格式 + IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp'] + + # ================= 执行区域 ================= + if 'TARGET_DIR' in locals(): + # 读取目录下所有图片文件，过滤掉 _result.jpg 后缀的文件 + image_files = [] + if os.path.exists(TARGET_DIR) and os.path.isdir(TARGET_DIR): + for filename in os.listdir(TARGET_DIR): + # 检查文件扩展名 + if any(filename.lower().endswith(ext) for ext in IMAGE_EXTENSIONS): + # 过滤掉 _result.jpg 后缀的文件 + if not filename.endswith('_result.jpg'): + filepath = os.path.join(TARGET_DIR, filename) + if os.path.isfile(filepath): + image_files.append(filepath) + + # 按文件名排序（可选） + image_files.sort() + + print(f"[INFO] 在目录 {TARGET_DIR} 中找到 {len(image_files)} 张图片") + + # 处理每张图片 + for img_path in image_files: + print(f"\n{'='*10} 开始处理: {img_path} {'='*10}") + run_offline_test(img_path) + else: + print(f"[ERROR] 目录不存在或不是有效目录: {TARGET_DIR}") + + else: + run_offline_test(TARGET_IMAGE) diff --git a/test/test_laser.py b/test/test_laser.py new file mode 100644 index 0000000..e54d743 --- /dev/null +++ b/test/test_laser.py @@ -0,0 +1,172 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +激光模块测试脚本 +用于诊断激光开关问题 + +使用方法： +python test_laser.py + +功能： +1. 初始化串口 +2. 循环测试激光开/关 +3. 打印详细调试信息 +""" + +from maix import uart, pinmap, time + +# ==================== 配置 ==================== +UART_PORT = "/dev/ttyS1" # 激光模块连接的串口（UART1） +BAUDRATE = 9600 # 波特率 + +# 引脚映射（确保与硬件连接一致） +print("=" * 50) +print("🔧 步骤1: 配置引脚映射") +print("=" * 50) + +try: + pinmap.set_pin_function("A18", "UART1_RX") + print("✅ A18 -> UART1_RX") +except Exception as e: + print(f"❌ A18 配置失败: {e}") + +try: + pinmap.set_pin_function("A19", "UART1_TX") + print("✅ A19 -> UART1_TX") +except Exception as e: + print(f"❌ A19 配置失败: {e}") + +# ==================== 激光控制指令 ==================== +MODULE_ADDR = 0x00 + +# 原始命令 +LASER_ON_CMD = bytes([0xAA, MODULE_ADDR, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x01, 0xC1]) +LASER_OFF_CMD = bytes([0xAA, MODULE_ADDR, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x00, 0xC0]) + +# 备用命令格式（如果原始命令不工作，可以尝试这些） +# 格式1: 简化命令 +LASER_ON_CMD_ALT1 = bytes([0xAA, 0x01, 0x01]) +LASER_OFF_CMD_ALT1 = bytes([0xAA, 0x01, 0x00]) + +# 格式2: 不同的协议头 +LASER_ON_CMD_ALT2 = bytes([0x55, 0xAA, 0x01]) +LASER_OFF_CMD_ALT2 = bytes([0x55, 0xAA, 0x00]) + +print("\n" + "=" * 50) +print("🔧 步骤2: 初始化串口") +print("=" * 50) +print(f"设备: {UART_PORT}") +print(f"波特率: {BAUDRATE}") + +try: + laser_uart = uart.UART(UART_PORT, BAUDRATE) + print(f"✅ 串口初始化成功: {laser_uart}") +except Exception as e: + print(f"❌ 串口初始化失败: {e}") + exit(1) + +# ==================== 测试函数 ==================== +def send_and_check(cmd, name): + """发送命令并检查回包""" + print(f"\n📤 发送: {name}") + print(f" 命令字节: {cmd.hex()}") + print(f" 命令长度: {len(cmd)} 字节") + + # 清空接收缓冲区 + try: + old_data = laser_uart.read(-1) + if old_data: + print(f" 清空缓冲区: {len(old_data)} 字节") + except: + pass + + # 发送命令 + try: + written = laser_uart.write(cmd) + print(f" 写入字节数: {written}") + except Exception as e: + print(f" ❌ 写入失败: {e}") + return None + + # 等待响应 + time.sleep_ms(100) + + # 读取回包 + try: + resp = laser_uart.read(50) + if resp: + print(f" 📥 收到回包: {resp.hex()} ({len(resp)} 字节)") + return resp + else: + print(f" ⚠️ 无回包") + return None + except Exception as e: + print(f" ❌ 读取失败: {e}") + return None + +def test_laser_cycle(on_cmd, off_cmd, cmd_name="标准命令"): + """测试一个开关周期""" + print(f"\n{'='*50}") + print(f"🧪 测试 {cmd_name}") + print(f"{'='*50}") + + print("\n>>> 测试开启激光") + send_and_check(on_cmd, f"{cmd_name} - 开启") + print(" ⏱️ 等待 2 秒观察激光是否亮起...") + time.sleep(2) + + print("\n>>> 测试关闭激光") + send_and_check(off_cmd, f"{cmd_name} - 关闭") + print(" ⏱️ 等待 2 秒观察激光是否熄灭...") + time.sleep(2) + +# ==================== 主测试 ==================== +print("\n" + "=" * 50) +print("🚀 开始激光测试") +print("=" * 50) +print("\n请观察激光模块的状态变化...") +print("测试将依次尝试不同的命令格式\n") + +try: + # 测试1: 标准命令 + test_laser_cycle(LASER_ON_CMD, LASER_OFF_CMD, "标准命令") + + input("\n按回车继续测试备用命令1...") + + # 测试2: 备用命令格式1 + test_laser_cycle(LASER_ON_CMD_ALT1, LASER_OFF_CMD_ALT1, "备用命令1 (简化)") + + input("\n按回车继续测试备用命令2...") + + # 测试3: 备用命令格式2 + test_laser_cycle(LASER_ON_CMD_ALT2, LASER_OFF_CMD_ALT2, "备用命令2 (0x55AA头)") + + print("\n" + "=" * 50) + print("🏁 测试完成") + print("=" * 50) + print("\n诊断建议：") + print("1. 如果激光始终不亮/始终亮：") + print(" - 检查激光模块的电源连接") + print(" - 检查串口TX/RX是否接反") + print(" - 尝试不同的波特率 (4800/19200)") + print("") + print("2. 如果有回包但激光无反应：") + print(" - 命令格式可能正确但激光硬件问题") + print("") + print("3. 如果某个备用命令有效：") + print(" - 需要更新 config.py 中的命令格式") + +except KeyboardInterrupt: + print("\n\n🛑 测试被中断") + # 确保激光关闭 + laser_uart.write(LASER_OFF_CMD) + print("✅ 已发送关闭指令") +except Exception as e: + print(f"\n❌ 测试出错: {e}") + import traceback + traceback.print_exc() + + + + + diff --git a/vision.py b/vision.py index efce364..7115900 100644 --- a/vision.py +++ b/vision.py @@ -14,6 +14,10 @@ from maix import image import config from logger_manager import logger_manager +# 导入ArUco检测器（如果启用） +if config.USE_ARUCO: + from aruco_detector import detect_target_with_aruco, aruco_detector + # 存图队列 + worker _save_queue = queue.Queue(maxsize=16) _save_worker_started = False @@ -749,3 +753,32 @@ def save_shot_image(result_img, center, radius, method, ellipse_params, logger.error(f"[VISION] save_shot_image 转换图像失败: {e}") return None + +def detect_target(frame, laser_point=None): + """ + 统一的靶心检测接口，根据配置自动选择检测方法 + + Args: + frame: MaixPy图像帧 + laser_point: 激光点坐标（可选） + + Returns: + (result_img, center, radius, method, best_radius1, ellipse_params) + 与detect_circle_v3保持相同的返回格式 + """ + logger = logger_manager.logger + + if config.USE_ARUCO: + # 使用ArUco检测 + if logger: + logger.debug("[VISION] 使用ArUco标记检测靶心") + + # 延迟导入以避免循环依赖 + from aruco_detector import detect_target_with_aruco + return detect_target_with_aruco(frame, laser_point) + else: + # 使用传统黄色靶心检测 + if logger: + logger.debug("[VISION] 使用传统黄色靶心检测") + return detect_circle_v3(frame, laser_point) +