AI台球助手核心架构与代码实现全解析｜2026年4月

import cv2
import numpy as np
from sklearn.cluster import DBSCAN

class BallDetector:
    """台球视觉识别模块"""
    
     标准台球直径57mm，对应像素值（需根据相机标定）
    BALL_DIAMETER_MM = 57
    BALL_DIAMETER_PX_RANGE = (22, 26)   俯拍高度1.2~1.5m时的经验值
    
    def __init__(self):
         各色球的HSV范围（需要根据实际环境微调）
        self.hsv_ranges = {
            'white': ([0, 0, 200], [180, 30, 255]),       白球：高亮度，低饱和度
            'red_1': ([0, 100, 100], [10, 255, 255]),     红球分支1
            'red_2': ([170, 100, 100], [180, 255, 255]),  红球分支2（环绕色）
            'yellow': ([20, 100, 100], [30, 255, 255]),
            'blue': ([100, 100, 100], [130, 255, 255]),
        }
        
    def detect_balls(self, image):
        """
        从图像中检测所有台球的位置和颜色
        返回: [(x, y, color), ...] 坐标单位为像素
        """
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
        all_balls = []
        
        for color_name, (lower, upper) in self.hsv_ranges.items():
            mask = cv2.inRange(hsv, np.array(lower), np.array(upper))
             形态学操作去噪
            mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3,3)))
             霍夫圆检测
            circles = cv2.HoughCircles(
                mask, cv2.HOUGH_GRADIENT, dp=1, minDist=30,
                param1=50, param2=30, minRadius=self.BALL_DIAMETER_PX_RANGE[0],
                maxRadius=self.BALL_DIAMETER_PX_RANGE[1]
            )
            if circles is not None:
                for x, y, r in circles[0]:
                    all_balls.append((int(x), int(y), color_name))
        
         DBSCAN聚类去重：合并紧贴球的多个检测点
        if len(all_balls) > 1:
            coords = np.array([[b[0], b[1]] for b in all_balls])
            clustering = DBSCAN(eps=15, min_samples=1).fit(coords)
            unique_balls = []
            for label in set(clustering.labels_):
                cluster = [all_balls[i] for i in range(len(all_balls)) 
                           if clustering.labels_[i] == label]
                 取聚类中心
                center_x = int(np.mean([c[0] for c in cluster]))
                center_y = int(np.mean([c[1] for c in cluster]))
                unique_balls.append((center_x, center_y, cluster[0][2]))
            return unique_balls
        
        return all_balls

class CoordinateMapper:
    """将像素坐标映射到真实台面坐标（单位：mm）"""
    
    def __init__(self, table_corners_px, table_real_size_mm=(2540, 1270)):
        """
        table_corners_px: 台桌四个角在图像中的像素坐标 [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
        table_real_size_mm: 台桌真实尺寸 (长, 宽)，标准花式台球桌约2540mm x 1270mm
        """
        self.real_width_mm, self.real_height_mm = table_real_size_mm
         计算单应性矩阵
        src_pts = np.float32(table_corners_px)
        dst_pts = np.float32([[0, 0], [self.real_width_mm, 0],
                               [self.real_width_mm, self.real_height_mm],
                               [0, self.real_height_mm]])
        self.homography_matrix, _ = cv2.findHomography(src_pts, dst_pts)
    
    def pixel_to_real(self, x_px, y_px):
        """将单个像素点转换为真实坐标"""
        pixel_point = np.float32([[[x_px, y_px]]])
        real_point = cv2.perspectiveTransform(pixel_point, self.homography_matrix)
        return real_point[0][0][0], real_point[0][0][1]   (x_mm, y_mm)

class PhysicsEngine:
    """台球物理仿真引擎（简化版）"""
    
    def __init__(self, friction=0.98, table_width_mm=2540, table_height_mm=1270):
        self.friction = friction            滚动摩擦系数
        self.table_width = table_width_mm    台桌宽度(mm)
        self.table_height = table_height_mm  台桌高度(mm)
    
    def predict_trajectory(self, cue_ball_pos, target_ball_pos, hit_angle_deg, power):
        """
        预测母球撞击目标球后的运动轨迹
        :param cue_ball_pos: 母球位置 (x, y) 单位mm
        :param target_ball_pos: 目标球位置 (x, y)
        :param hit_angle_deg: 击球角度（度）
        :param power: 击球力度（0~100）
        :return: 母球轨迹点列表，目标球轨迹点列表
        """
         计算撞击方向
        dx = target_ball_pos[0] - cue_ball_pos[0]
        dy = target_ball_pos[1] - cue_ball_pos[1]
        dist = np.sqrt(dx2 + dy2)
        
         初速度（力度映射到速度，单位mm/帧）
        velocity = power  2.5   简化映射
        
         模拟母球撞击前的运动
        cue_trajectory = self._simulate_motion(cue_ball_pos, 
                                                 (dx/dist, dy/dist), 
                                                 velocity, dist)
        
         撞击后：动量转移（弹性碰撞简化模型）
         母球速度下降，目标球获得速度
        cue_post_velocity = velocity  0.3    母球残余速度
        target_velocity = velocity  0.7      目标球获得速度
        
         撞击后母球的运动方向（近似沿切向偏转）
        perp_dx, perp_dy = -dy, dx
        perp_norm = np.sqrt(perp_dx2 + perp_dy2)
        if perp_norm > 0:
            perp_dx /= perp_norm
            perp_dy /= perp_norm
        
         模拟撞击后轨迹
        cue_after = self._simulate_motion(target_ball_pos, 
                                           (perp_dx, perp_dy), 
                                           cue_post_velocity, 
                                           self.table_width)
        target_after = self._simulate_motion(target_ball_pos,
                                              (dx/dist, dy/dist),
                                              target_velocity,
                                              self.table_width)
        
        return cue_trajectory + cue_after, target_after
    
    def _simulate_motion(self, start_pos, direction, init_velocity, max_distance):
        """模拟球体运动至停止，返回轨迹点列表"""
        trajectory = [start_pos]
        x, y = start_pos
        vx, vy = direction[0]  init_velocity, direction[1]  init_velocity
        
        while abs(vx) > 0.5 or abs(vy) > 0.5:
             应用摩擦减速
            vx = self.friction
            vy = self.friction
            x += vx
            y += vy
            
             边界碰撞处理（库边反弹）
            if x < 0 or x > self.table_width:
                vx = -vx
                x = max(0, min(x, self.table_width))
            if y < 0 or y > self.table_height:
                vy = -vy
                y = max(0, min(y, self.table_height))
            
            trajectory.append((x, y))
        
        return trajectory

def ai_billiards_assistant_pipeline():
    """
    AI台球助手完整处理流程
    """
     Step 1: 加载图像（实际应用中由摄像头实时捕获）
    image = cv2.imread("pool_table.jpg")
    
     Step 2: 视觉识别
    detector = BallDetector()
    balls_px = detector.detect_balls(image)   [(x, y, color), ...]
    print(f"识别到 {len(balls_px)} 颗球")
    
     Step 3: 坐标映射
     手动标定台桌四角像素坐标（实际应用中自动检测）
    corners_px = [[100, 100], [1800, 100], [1800, 1200], [100, 1200]]
    mapper = CoordinateMapper(corners_px)
    balls_real = [(mapper.pixel_to_real(x, y), color) for (x, y, color) in balls_px]
    
     Step 4: 分离母球与目标球
    cue_ball = next((pos for pos, color in balls_real if color == 'white'), None)
    target_balls = [(pos, color) for pos, color in balls_real if color != 'white']
    
     Step 5: 物理仿真预测
    engine = PhysicsEngine()
    for target_pos, color in target_balls:
        cue_traj, target_traj = engine.predict_trajectory(
            cue_ball, target_pos, hit_angle_deg=45, power=70
        )
        print(f"预测击打{color}球: 母球走位{len(cue_traj)}步，目标球走位{len(target_traj)}步")
    
     Step 6: 可视化推荐（在图像上绘制辅助线）
     ... 在图像上叠加轨迹线并展示给用户

if __name__ == "__main__":
    ai_billiards_assistant_pipeline()