feat: AI套图分层方案 + Gemini集成 - 4种图案类型处理 + 正片叠底 + 宽高比 + 模型选择

Co-authored-by: Cursor <cursoragent@cursor.com>

run.py

@@ -0,0 +1,418 @@
+import cv2
+import numpy as np
+import os
+import time
+from PIL import Image
+from pltreader import PltReader
+from concurrent.futures import ThreadPoolExecutor
+from shapely import affinity
+from scipy.optimize import linear_sum_assignment
+
+def get_single_size_info(filepath, size_num, english_name):
+    with open(filepath, 'r') as f:
+        reader = PltReader(f)
+        output = reader.get_output(tolerance=10)
+
+        # 整幅输出
+        full_sheet_path = english_name + '_full_sheet.png'
+        cv2.imwrite(full_sheet_path, output.debug_full_sheet(scale_factor=72/1016))
+        #cv2.imwrite(full_sheet_path, output.debug_full_sheet(scale_factor=0.1))
+        print(f"已保存整幅裁片图像到: {full_sheet_path}")
+
+        # 获取单片输出信息
+        return output.get_single_size_info(size_num=size_num)
+
+def get_principal_angle(polygon):
+    '''计算主轴角度'''
+    coords = np.array(polygon.exterior.coords)
+    # 计算协方差矩阵
+    cov = np.cov(coords.T)
+    # 特征值分解
+    eig_vals, eig_vecs = np.linalg.eig(cov)
+    # 找到最大特征值对应的特征向量
+    principal_vec = eig_vecs[:, np.argmax(eig_vals)]
+    # 计算角度
+    angle = np.degrees(np.arctan2(principal_vec[1], principal_vec[0]))
+    return angle
+
+def get_different_size_match_result(clusters):
+    base_cluster = [piece for piece in clusters[0] if piece["parent"] == None]
+    result = {piece["index"]:[] for piece in base_cluster}
+
+    for size_index in range(1, len(clusters)):
+        compare_cluster = [piece for piece in clusters[size_index] if piece["parent"] == None]
+        assert len(base_cluster) == len(compare_cluster)
+
+        # 初始化成本矩阵
+        cost_matrix = np.zeros((len(base_cluster), len(base_cluster)))
+        # 初始化旋转角度矩阵，表示每个裁片的最佳旋转角度
+        rotation_matrix = np.zeros((len(base_cluster), len(base_cluster)))
+
+        # 把每个裁片对应上
+        for i in range(len(base_cluster)):
+            for j in range(len(compare_cluster)):
+                poly1 = base_cluster[i]["data"]
+                poly2 = compare_cluster[j]["data"]
+
+                # 质心对齐
+                poly1 = affinity.translate(poly1, xoff=-poly1.centroid.x, yoff=-poly1.centroid.y)
+                poly2 = affinity.translate(poly2, xoff=-poly2.centroid.x, yoff=-poly2.centroid.y)
+
+                # 缩放到相同面积
+                target_area = 10000
+                scale_factor1 = (target_area / poly1.area) ** 0.5
+                scale_factor2 = (target_area / poly2.area) ** 0.5
+                # 绕原点缩放
+                poly1 = affinity.scale(poly1, xfact=scale_factor1, yfact=scale_factor1, origin=(0, 0))
+                poly2 = affinity.scale(poly2, xfact=scale_factor2, yfact=scale_factor2, origin=(0, 0))
+
+                candidates = [0, 90, 180, 270]
+
+                dist_min = float('inf')
+                best_angle = 0
+                for angle in candidates:
+                    rotated_back = affinity.rotate(poly2, angle, origin='centroid')
+                    dist = poly1.hausdorff_distance(rotated_back)
+                    if dist < dist_min:
+                        dist_min = dist
+                        best_angle = angle
+
+                cost_matrix[i, j] = dist_min
+                rotation_matrix[i, j] = best_angle
+
+        row_ind, col_ind = linear_sum_assignment(cost_matrix)
+        for i, j in zip(row_ind, col_ind):
+            result[base_cluster[i]['index']].append((compare_cluster[j]['index'], cost_matrix[i, j], rotation_matrix[i, j]))
+
+    for base_index, matches in result.items():
+        print(f"{base_index} <->", end=" ")
+        for match in matches:
+            print(f"{match[0]} (d={match[1]:.2f}  r={match[2]}°)", end="; ")
+        print()
+    print("\n")
+    
+    return result
+
+
+def export_pieces_by_size_group(filepath, size_labels, output_dir="output", dpi=150, rotation=0):
+    """
+    按尺码和组号导出裁片PNG
+    
+    Args:
+        filepath: PLT文件路径
+        size_labels: 尺码标签列表，如 ["S", "M", "L", "XL", "2XL", "3XL", "4XL"]
+        output_dir: 输出目录
+        dpi: 输出分辨率 (DPI)
+        rotation: 旋转角度，可选值:
+            0   - 不旋转
+            90  - 顺时针旋转90°
+            -90 - 逆时针旋转90°
+            180 - 旋转180°
+    
+    输出文件命名: S-1.png, M-1.png, L-1.png, ...
+    """
+    start_time = time.time()
+    
+    # 根据 DPI 计算 scale_factor (1016 绘图仪单位 = 1 英寸)
+    scale_factor = dpi / 1016
+    size_num = len(size_labels)
+    
+    print(f"==========开始读取PLT文件: {filepath}==========")
+    with open(filepath, 'r') as f:
+        reader = PltReader(f)
+        output = reader.get_output(tolerance=10)
+    
+    # 获取尺码聚类信息
+    clusters = output.get_single_size_info(size_num=size_num)
+    
+    # 获取不同尺码间的匹配关系
+    print("==========开始匹配不同尺码的相同裁片==========")
+    base_cluster = [piece for piece in clusters[0] if piece["parent"] == None]
+    match_result = {piece["index"]: [piece["index"]] for piece in base_cluster}  # 基准尺码的index作为key
+    
+    for size_index in range(1, len(clusters)):
+        compare_cluster = [piece for piece in clusters[size_index] if piece["parent"] == None]
+        
+        # 初始化成本矩阵
+        cost_matrix = np.zeros((len(base_cluster), len(compare_cluster)))
+        
+        for i in range(len(base_cluster)):
+            for j in range(len(compare_cluster)):
+                poly1 = base_cluster[i]["data"]
+                poly2 = compare_cluster[j]["data"]
+                
+                # 质心对齐
+                poly1 = affinity.translate(poly1, xoff=-poly1.centroid.x, yoff=-poly1.centroid.y)
+                poly2 = affinity.translate(poly2, xoff=-poly2.centroid.x, yoff=-poly2.centroid.y)
+                
+                # 缩放到相同面积
+                target_area = 10000
+                scale_factor1 = (target_area / poly1.area) ** 0.5
+                scale_factor2 = (target_area / poly2.area) ** 0.5
+                poly1 = affinity.scale(poly1, xfact=scale_factor1, yfact=scale_factor1, origin=(0, 0))
+                poly2 = affinity.scale(poly2, xfact=scale_factor2, yfact=scale_factor2, origin=(0, 0))
+                
+                # 尝试不同旋转角度
+                dist_min = float('inf')
+                for angle in [0, 90, 180, 270]:
+                    rotated = affinity.rotate(poly2, angle, origin='centroid')
+                    dist = poly1.hausdorff_distance(rotated)
+                    if dist < dist_min:
+                        dist_min = dist
+                
+                cost_matrix[i, j] = dist_min
+        
+        # 匈牙利算法匹配
+        row_ind, col_ind = linear_sum_assignment(cost_matrix)
+        for i, j in zip(row_ind, col_ind):
+            base_index = base_cluster[i]['index']
+            matched_index = compare_cluster[j]['index']
+            match_result[base_index].append(matched_index)
+    
+    # 创建输出目录
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 构建 index -> node 的映射（包含所有节点，不只是parent为None的）
+    all_nodes = {node["index"]: node for node in output.nodes}
+    
+    # 导出图片
+    rotation_desc = {0: "不旋转", 90: "顺时针90°", -90: "逆时针90°", 180: "旋转180°"}.get(rotation, f"旋转{rotation}°")
+    print(f"==========开始导出裁片图片到: {output_dir}/ ({rotation_desc})==========")
+    group_id = 1
+    for base_index, matched_indices in match_result.items():
+        print(f"组 {group_id}: ", end="")
+        for size_idx, piece_index in enumerate(matched_indices):
+            size_label = size_labels[size_idx]
+            
+            # 找到对应的node（包括其子节点）
+            node = all_nodes[piece_index]
+            nodes_to_draw = [node] + node['child']
+            
+            # 绘制图像
+            img = output._draw_nodes(nodes_to_draw, scale_factor, show_id=False)
+            
+            # OpenCV 的 BGRA 转 Pillow 的 RGBA
+            img_rgba = cv2.cvtColor(img, cv2.COLOR_BGRA2RGBA)
+            pil_img = Image.fromarray(img_rgba)
+            
+            # 应用旋转
+            if rotation == 90:
+                pil_img = pil_img.rotate(-90, expand=True)  # Pillow的rotate是逆时针，所以用负值实现顺时针
+            elif rotation == -90:
+                pil_img = pil_img.rotate(90, expand=True)   # 逆时针90°
+            elif rotation == 180:
+                pil_img = pil_img.rotate(180, expand=True)
+            
+            # 保存文件（写入 DPI 元数据）
+            filename = f"{size_label}-{group_id}.png"
+            filepath_out = os.path.join(output_dir, filename)
+            pil_img.save(filepath_out, dpi=(dpi, dpi))
+            print(f"{filename}", end=" ")
+        
+        print()
+        group_id += 1
+    
+    print(f"\n导出完成！共 {group_id - 1} 组裁片，每组 {len(size_labels)} 个尺码")
+    print(f"文件保存在: {output_dir}/")
+    
+    # ========== 输出每个尺码的裁片中心坐标 ==========
+    SAFETY_MARGIN = 10  # 安全边距 10cm
+    
+    print("\n" + "=" * 70)
+    print(f"裁片中心坐标（单位: cm，原点: 左下角，安全边距: {SAFETY_MARGIN}cm，{rotation_desc}）")
+    print("=" * 70)
+    
+    # PLT单位转厘米的系数 (1016单位 = 1英寸 = 2.54cm)
+    plt_to_cm = 2.54 / 1016
+    
+    # 按尺码分组输出坐标
+    for size_idx, size_label in enumerate(size_labels):
+        # 收集该尺码下所有裁片
+        size_pieces = []
+        for base_index, matched_indices in match_result.items():
+            piece_index = matched_indices[size_idx]
+            node = all_nodes[piece_index]
+            polygon = node["data"]
+            size_pieces.append({
+                "group_id": list(match_result.keys()).index(base_index) + 1,
+                "polygon": polygon,
+                "centroid": polygon.centroid
+            })
+        
+        # 计算该尺码的边界框（用于重置原点）
+        all_polygons = [p["polygon"] for p in size_pieces]
+        from shapely.geometry import MultiPolygon as ShapelyMultiPolygon
+        multi_poly = ShapelyMultiPolygon(all_polygons)
+        min_x, min_y, max_x, max_y = multi_poly.bounds
+        
+        # 原始画布尺寸（厘米）
+        orig_width_cm = (max_x - min_x) * plt_to_cm
+        orig_height_cm = (max_y - min_y) * plt_to_cm
+        
+        # 根据旋转调整画布宽高
+        if rotation in [90, -90]:
+            width_cm, height_cm = orig_height_cm, orig_width_cm  # 宽高互换
+        else:
+            width_cm, height_cm = orig_width_cm, orig_height_cm
+        
+        # 含安全边距的画布尺寸
+        total_width_cm = width_cm + 2 * SAFETY_MARGIN
+        total_height_cm = height_cm + 2 * SAFETY_MARGIN
+        
+        print(f"\n【尺码 {size_label}】")
+        print(f"  裁片区域尺寸: 宽 {width_cm:.2f} cm, 高 {height_cm:.2f} cm")
+        print(f"  含安全边距尺寸: 宽 {total_width_cm:.2f} cm, 高 {total_height_cm:.2f} cm")
+        print("-" * 70)
+        print(f"  {'裁片名称':<10} {'原始中心坐标':<22} {'含安全边距坐标':<22} {'裁片尺寸'}")
+        print("-" * 70)
+        
+        for piece in size_pieces:
+            # 原始坐标（以左下角为原点，Y轴向上）
+            orig_center_x = (piece["centroid"].x - min_x) * plt_to_cm
+            orig_center_y = (piece["centroid"].y - min_y) * plt_to_cm
+            
+            # 原始裁片尺寸
+            piece_bounds = piece["polygon"].bounds
+            orig_piece_width = (piece_bounds[2] - piece_bounds[0]) * plt_to_cm
+            orig_piece_height = (piece_bounds[3] - piece_bounds[1]) * plt_to_cm
+            
+            # 根据旋转变换坐标
+            if rotation == 90:  # 顺时针90°
+                center_x = orig_center_y
+                center_y = orig_width_cm - orig_center_x
+                piece_width, piece_height = orig_piece_height, orig_piece_width
+            elif rotation == -90:  # 逆时针90°
+                center_x = orig_height_cm - orig_center_y
+                center_y = orig_center_x
+                piece_width, piece_height = orig_piece_height, orig_piece_width
+            elif rotation == 180:  # 旋转180°
+                center_x = orig_width_cm - orig_center_x
+                center_y = orig_height_cm - orig_center_y
+                piece_width, piece_height = orig_piece_width, orig_piece_height
+            else:  # 不旋转
+                center_x, center_y = orig_center_x, orig_center_y
+                piece_width, piece_height = orig_piece_width, orig_piece_height
+            
+            # 含安全边距的坐标（加上10cm偏移）
+            safe_x = center_x + SAFETY_MARGIN
+            safe_y = center_y + SAFETY_MARGIN
+            
+            # 裁片名称与PNG文件名一致
+            piece_name = f"{size_label}-{piece['group_id']}"
+            print(f"  {piece_name:<10} ({center_x:7.2f}, {center_y:7.2f}) cm  ({safe_x:7.2f}, {safe_y:7.2f}) cm  {piece_width:.2f} x {piece_height:.2f} cm")
+    
+    print("\n" + "=" * 70)
+    
+    # 计算并显示处理时间
+    elapsed_time = time.time() - start_time
+    if elapsed_time >= 60:
+        minutes = int(elapsed_time // 60)
+        seconds = elapsed_time % 60
+        print(f"处理耗时: {minutes}分{seconds:.2f}秒")
+    else:
+        print(f"处理耗时: {elapsed_time:.2f}秒")
+
+
+def get_contour_match_result(standard_clusters, rotated_clusters):
+
+    for standard_cluster, rotated_cluster in zip(standard_clusters, rotated_clusters):
+        # 仅保留父节点
+        standard_cluster = [piece for piece in standard_cluster if piece["parent"] == None]
+        rotated_cluster = [piece for piece in rotated_cluster if piece["parent"] == None]
+        assert len(standard_cluster) == len(rotated_cluster)
+
+        # 初始化成本矩阵
+        cost_matrix = np.zeros((len(standard_cluster), len(standard_cluster)))
+        # 初始化旋转角度矩阵，表示每个裁片的最佳旋转角度
+        rotation_matrix = np.zeros((len(standard_cluster), len(standard_cluster)))
+
+        # 把旋转后的每个裁片和标准的裁片对应上
+        for i in range(len(standard_cluster)):
+            for j in range(len(rotated_cluster)):
+                poly1 = standard_cluster[i]["data"]
+                poly2 = rotated_cluster[j]["data"]
+
+                #poly1 = poly1.simplify(0)
+                #poly2 = poly2.simplify(0)
+
+                # 质心对齐
+                poly1 = affinity.translate(poly1, xoff=-poly1.centroid.x, yoff=-poly1.centroid.y)
+                poly2 = affinity.translate(poly2, xoff=-poly2.centroid.x, yoff=-poly2.centroid.y)
+
+                # 计算主轴角度
+                #angle1 = get_principal_angle(poly1)
+                #angle2 = get_principal_angle(poly2)
+
+                # 计算角度差
+                #angle_diff = angle1 - angle2
+                #candidates = [angle_diff, angle_diff + 90, angle_diff + 180, angle_diff + 270]
+                candidates = [0, 90, 180, 270]
+
+                dist_min = float('inf')
+                best_angle = 0
+                for angle in candidates:
+                    rotated_back = affinity.rotate(poly2, angle, origin='centroid')
+                    dist = poly1.hausdorff_distance(rotated_back)
+                    if dist < dist_min:
+                        dist_min = dist
+                        best_angle = angle
+
+                cost_matrix[i, j] = dist_min
+                rotation_matrix[i, j] = best_angle
+
+        row_ind, col_ind = linear_sum_assignment(cost_matrix)
+        print("\n标准裁片与旋转后裁片的最佳匹配结果:")
+        for i, j in zip(row_ind, col_ind):
+            print(f"标准裁片ID: {standard_cluster[i]['index']}, 旋转后裁片ID: {rotated_cluster[j]['index']}, 距离: {cost_matrix[i, j]:.4f}, 最佳旋转角度: {rotation_matrix[i, j]}度")
+        # 打印成本矩阵
+        #print(cost_matrix)
+
+
+def main():
+
+    STANDARD_FILE_PATH = "默认方案-POLO衫长袖-A料-标准.plt"
+    ROTATED_FILE_PATH = "默认方案-POLO衫长袖-A料-已旋转.plt"
+    SIZE_NUM = 5
+    
+    # ========== 新功能：按尺码分组导出裁片 ==========
+    # 尺码标签列表（根据你的实际情况修改）
+    SIZE_LABELS = ["S", "M", "L", "XL", "2XL"]
+    
+    # 导出标准文件的裁片（按 S-1, M-1, L-1... 命名）
+    export_pieces_by_size_group(
+        filepath=STANDARD_FILE_PATH,
+        size_labels=SIZE_LABELS,
+        output_dir="standard_pieces",
+        dpi=150,  # 输出分辨率，Photoshop 会正确识别
+        rotation=90  # 顺时针旋转90°
+    )
+    
+    # 如果需要导出旋转后文件的裁片，取消下面的注释
+    # export_pieces_by_size_group(
+    #     filepath=ROTATED_FILE_PATH,
+    #     size_labels=SIZE_LABELS,
+    #     output_dir="rotated_pieces",
+    #     scale_factor=72/1016
+    # )
+    
+    # ========== 以下是原有的匹配功能 ==========
+    # print("==========开始读取轮廓数据==========")
+    # with ThreadPoolExecutor(max_workers=2) as executor:
+    #     standard_future = executor.submit(get_single_size_info, STANDARD_FILE_PATH, SIZE_NUM, "standard")
+    #     rotated_future = executor.submit(get_single_size_info, ROTATED_FILE_PATH, SIZE_NUM, "rotated")
+    #
+    #     standard_clusters = standard_future.result()
+    #     rotated_clusters = rotated_future.result()
+    #
+    # print("==========开始获取两个文件的轮廓匹配结果==========")
+    # get_contour_match_result(standard_clusters, rotated_clusters)
+    #
+    # print("==========开始获取一个文件内不同尺寸的匹配结果==========")
+    # print(f"{STANDARD_FILE_PATH}:")
+    # get_different_size_match_result(standard_clusters)
+    # print(f"{ROTATED_FILE_PATH}:")
+    # get_different_size_match_result(rotated_clusters)
+
+
+if __name__ == "__main__":
+    main()