import os import string from datetime import time import random import cv2 import numpy import numpy as np import matplotlib.pyplot as plt from skimage.morphology import skeletonize from pathlib import Path import json # ================= 配置参数 ================= # DEFAULT_INPUT = "/path/to/dataset/circle_id/images" # DEFAULT_INPUT = "/nas-02/hdd/public_datasets/icdar-2026-circleid-writer-identification/images/" # DEFAULT_OUTPUT = "/path/to/circle_id/circle_output/polar_order/orignal_size/images/" # DEFAULT_INPUT = "/nas-02/hdd/public_datasets/icdar-2026-circleid-writer-identification/ours_images/" # DEFAULT_OUTPUT = "/path/to/circle_id/circle_output/polar_order/orignal_size/ours_images/" DEFAULT_INPUT = "/path/to/circle_id/images/images/39557.png" DEFAULT_OUTPUT = "/path/to/circle_id/outputs/polar_order/temp/" N_SAMPLES = 120 ANGLE_TOLERANCE = 1.5 RADIUS_DIFF_THRESHOLD = 5.0 # ================= 1. 椭圆拟合 ================= def fit_ellipse_from_skeleton(skeleton_mask): """从骨架图像拟合椭圆""" points_y, points_x = np.where(skeleton_mask > 0) skeleton_points = np.column_stack((points_x, points_y)) if len(skeleton_points) < 5: print(f"二值图骨架异常,skeleton_points:{len(skeleton_points)}") return None, None contour = skeleton_points.reshape(-1, 1, 2).astype(np.float32) (cx, cy), (axis1, axis2), angle_raw = cv2.fitEllipse(contour) if axis1 >= axis2: MA, ma = axis1, axis2 angle = angle_raw else: MA, ma = axis2, axis1 angle = angle_raw + 90.0 if angle >= 180.0: angle -= 180.0 if MA < 30: # print(f"椭圆大小异常{MA}") return None, None a, b = MA / 2.0, ma / 2.0 angle_rad = np.radians(angle) cos_t, sin_t = np.cos(angle_rad), np.sin(angle_rad) errors = [] for x, y in skeleton_points: dx, dy = x - cx, y - cy x_rot = dx * cos_t + dy * sin_t y_rot = -dx * sin_t + dy * cos_t val = (x_rot ** 2 / a ** 2) + (y_rot ** 2 / b ** 2) if val > 0: err = abs(np.sqrt(val) - 1.0) * ((a + b) / 2.0) errors.append(err) fit_error = np.mean(errors) if errors else 0.0 ellipse_params = { 'cx': cx, 'cy': cy, 'MA': MA, 'ma': ma, 'a': a, 'b': b, 'angle': angle, 'angle_rad': angle_rad, 'fit_error': fit_error } return ellipse_params, skeleton_points # ================= 2. 极坐标转换 ================= def cartesian_to_polar(points, center): """将笛卡尔坐标转换为极坐标""" dx = points[:, 0] - center[0] dy = points[:, 1] - center[1] r = np.sqrt(dx ** 2 + dy ** 2) theta = np.degrees(np.arctan2(dy, dx)) theta = (theta + 360) % 360 return r, theta def polar_to_cartesian(r, theta_deg, center): """将极坐标转换回笛卡尔坐标""" theta_rad = np.radians(theta_deg) x = center[0] + r * np.cos(theta_rad) y = center[1] + r * np.sin(theta_rad) return np.array([x, y]) # ================= 3. 椭圆理论半径计算 ================= def ellipse_radius_at_angle(ellipse_params, theta_deg): """ 计算椭圆在指定几何角度下的理论半径(全局坐标系) 参数: ellipse_params: 椭圆参数字典 theta_deg: 全局坐标系下的角度(相对于图像 x 轴,0~360°) 返回: radius: 该角度下椭圆边界点到中心的距离(像素) """ a = ellipse_params['a'] # 长半轴 b = ellipse_params['b'] # 短半轴 angle_rad = ellipse_params['angle_rad'] # 长轴相对于全局 x 轴的角度 # 1. 将全局角度转换到椭圆局部坐标系(相对于长轴) theta_rad = np.radians(theta_deg) phi = theta_rad - angle_rad # 2. 椭圆极坐标方程(几何角度→半径) x_local = a * np.cos(phi) y_local = b * np.sin(phi) radius = np.sqrt(x_local ** 2 + y_local ** 2) return radius # ================= 4. 核心:120 维特征提取(优化版)================= def extract_polar_ordered_features(skeleton_mask, ellipse_params, n_samples=N_SAMPLES, angle_tolerance=ANGLE_TOLERANCE, radius_diff_threshold=RADIUS_DIFF_THRESHOLD): """ 🔧 优化版:逆时针采样 + 特征规范化 改进: 1. 角度迭代:逆时针旋转 (angle + i*3) 2. 特征规范化:角度→弧度,半径→除以长半轴 a 3. 保留 matched_points 坐标 """ cx, cy = ellipse_params['cx'], ellipse_params['cy'] a = ellipse_params['a'] # 长半轴,用于半径归一化 # 1. 提取所有骨架点并转换为极坐标 points_y, points_x = np.where(skeleton_mask > 0) skeleton_points = np.column_stack((points_x, points_y)) # 转换为极坐标 r_vals, theta_vals = cartesian_to_polar(skeleton_points, (cx, cy)) features = [] matched_points = [] # 🔧 保留原始坐标 prev_point = None for i in range(n_samples): # 2. 🔧 计算当前采样角度(逆时针) t_theta_deg = (i * 360 / n_samples) % 360 t_r = ellipse_radius_at_angle(ellipse_params, t_theta_deg) # 🔧 规范化理论值 t_theta_rad = np.radians(t_theta_deg) t_r_norm = t_r / a # 3. 在容差范围内找候选点 theta_lower = (t_theta_deg - angle_tolerance + 360) % 360 theta_upper = (t_theta_deg + angle_tolerance) % 360 if theta_lower > theta_upper: mask = (theta_vals >= theta_lower) | (theta_vals <= theta_upper) else: mask = (theta_vals >= theta_lower) & (theta_vals <= theta_upper) candidate_indices = np.where(mask)[0] if len(candidate_indices) == 0: # 无匹配,填充规范化默认值 features.append(numpy.array([t_r_norm, t_theta_rad/6.283, 0, 0, t_r_norm, t_theta_rad/6.283, 0, 0])) matched_points.append(numpy.array([-1, -1])) continue # 提取候选点属性 candidate_r = r_vals[candidate_indices] candidate_theta = theta_vals[candidate_indices] candidate_points = skeleton_points[candidate_indices] # 计算角度差异 angle_diff = np.abs(candidate_theta - t_theta_deg) angle_diff = np.minimum(angle_diff, 360 - angle_diff) # 计算半径差异 radius_diff_to_theory = np.abs(candidate_r - t_r) # 找角度最接近的 2 个点 if len(candidate_indices) >= 2: top_2_local_idx = np.argsort(angle_diff)[:2] else: top_2_local_idx = np.array([0]) refined_r = candidate_r[top_2_local_idx] refined_theta = candidate_theta[top_2_local_idx] refined_angle_diff = angle_diff[top_2_local_idx] refined_radius_diff = radius_diff_to_theory[top_2_local_idx] refined_global_idx = candidate_indices[top_2_local_idx] # 根据半径差异阈值决定选择策略 if len(top_2_local_idx) >= 2: r1, r2 = refined_r[0], refined_r[1] radius_diff_between_candidates = abs(r1 - r2) if radius_diff_between_candidates < radius_diff_threshold: strategy = 0.5 # 角度优先 best_local_idx = np.argmin(refined_angle_diff) else: strategy = 1 # 半径优先 best_local_idx = np.argmin(refined_radius_diff) best_global_idx = refined_global_idx[best_local_idx] else: best_global_idx = candidate_indices[0] strategy = 0.5 # 获取最优匹配点 best_r = r_vals[best_global_idx] best_theta_deg = theta_vals[best_global_idx] best_point = skeleton_points[best_global_idx] # 🔧 保留原始 (x, y) 坐标 # 🔧 规范化实际值 best_r_norm = best_r / a best_theta_rad = np.radians(best_theta_deg) # 计算 dis(欧氏距离) todo dis = 0.0 # 误差计算 e_r_norm = t_r_norm - best_r_norm e_theta_rad = t_theta_rad - best_theta_rad # 🔧 特征格式(全部规范化): # (t_r_norm, t_theta_rad, r_norm, theta_rad, e_r_norm, e_theta_rad, dis, strategy) features.append(numpy.array([t_r_norm, t_theta_rad/6.283, best_r_norm, best_theta_rad/6.283, e_r_norm, e_theta_rad/6.283, dis, strategy])) matched_points.append(best_point.astype(int)) # 🔧 保留原始坐标 prev_point = best_point return numpy.array(features), numpy.array(matched_points) # ================= 5. 可视化(适配规范化特征)================= def visualize_polar_sampling( original_img, skeleton_mask, ellipse_params, features, matched_points, output_path='polar_sampling.png' ): """可视化极坐标采样结果(适配规范化特征)""" fig, axes = plt.subplots(1, 2, figsize=(18, 7)) cx, cy = ellipse_params['cx'], ellipse_params['cy'] a, b = ellipse_params['a'], ellipse_params['b'] angle = ellipse_params['angle'] angle_rad = ellipse_params['angle_rad'] # ========== 图 1: 原始图 + 椭圆 + 轴 + 采样点 ========== axes[0].imshow(cv2.cvtColor(original_img, cv2.COLOR_BGR2RGB)) axes[0].set_title('原始图像 + 椭圆拟合 + 采样点', fontsize=12) axes[0].axis('off') from matplotlib.patches import Ellipse ellipse = Ellipse( (cx, cy), ellipse_params['MA'], ellipse_params['ma'], angle=angle, fill=False, color='blue', linewidth=2, linestyle='--', label='拟合椭圆', alpha=0.7 ) axes[0].add_patch(ellipse) # 绘制椭圆中心 axes[0].scatter(cx, cy, c='red', s=100, marker='*', edgecolors='white', linewidths=2, label=f'中心 ({cx:.1f}, {cy:.1f})', zorder=10) # 绘制长轴和短轴 major_axis_end1 = (cx + a * np.cos(angle_rad), cy + a * np.sin(angle_rad)) major_axis_end2 = (cx - a * np.cos(angle_rad), cy - a * np.sin(angle_rad)) minor_axis_end1 = (cx - b * np.sin(angle_rad), cy + b * np.cos(angle_rad)) minor_axis_end2 = (cx + b * np.sin(angle_rad), cy - b * np.cos(angle_rad)) axes[0].plot([major_axis_end1[0], major_axis_end2[0]], [major_axis_end1[1], major_axis_end2[1]], 'r-', linewidth=2, label=f'长轴 ({ellipse_params["MA"]:.1f})', zorder=5) axes[0].plot([minor_axis_end1[0], minor_axis_end2[0]], [minor_axis_end1[1], minor_axis_end2[1]], 'g-', linewidth=2, label=f'短轴 ({ellipse_params["ma"]:.1f})', zorder=5) # 标注 theta=0 的角度(长轴方向) arrow_length = a * 0.8 arrow_end = (cx + arrow_length * np.cos(0), cy + arrow_length * np.sin(0)) axes[0].annotate('', xy=arrow_end, xytext=(cx, cy), arrowprops=dict(arrowstyle='->', color='orange', linewidth=3, ls='-')) axes[0].text(arrow_end[0] + 10, arrow_end[1], 'θ=0°', fontsize=10, color='orange', fontweight='bold', bbox=dict(facecolor='white', alpha=0.7)) # 绘制采样点(区分策略) angle_priority_count = 0 radius_priority_count = 0 missing_count = 0 for i, (t_r_norm, t_theta_rad, r_norm, theta_rad, e_r_norm, e_theta_rad, dis, strategy) in enumerate(features): # 🔧 反规范化用于可视化:弧度→度数,归一化半径→实际半径 t_theta_deg = np.degrees(t_theta_rad) t_r = t_r_norm * a t_point = polar_to_cartesian(t_r, t_theta_deg, (cx, cy)) if matched_points[i] is not None: if strategy == 1: axes[0].scatter(matched_points[i][0], matched_points[i][1], c='cyan', s=25, marker='o', edgecolors='white', linewidths=1, alpha=0.8) angle_priority_count += 1 elif strategy == 2: axes[0].scatter(matched_points[i][0], matched_points[i][1], c='yellow', s=25, marker='o', edgecolors='black', linewidths=1, alpha=0.8) radius_priority_count += 1 else: axes[0].scatter(t_point[0], t_point[1], c='red', s=25, marker='o', edgecolors='white', linewidths=1, alpha=0.8) missing_count += 1 legend_text = f'✅ 角度优先:{angle_priority_count}\n✅ 半径优先:{radius_priority_count}\n❌ 缺失:{missing_count}' axes[0].text(10, 30, legend_text, fontsize=10, bbox=dict(facecolor='white', alpha=0.9, edgecolor='black')) axes[0].legend(loc='upper right', fontsize=8) # ========== 图 2: 极坐标展开图 ========== axes[1].set_title('极坐标展开图 (顺时针 0°→360°)', fontsize=12) axes[1].set_xlabel('角度 (°)') axes[1].set_ylabel('归一化半径 (r/a)') axes[1].grid(alpha=0.3) # 理论椭圆半径曲线(归一化) angles_deg = np.linspace(0, 360, 360) theoretical_radii_norm = [ellipse_radius_at_angle(ellipse_params, ang) / a for ang in angles_deg] axes[1].plot(angles_deg, theoretical_radii_norm, 'b--', linewidth=1, label='理论椭圆半径 (归一化)', alpha=0.6) # 实际匹配点(区分策略,使用归一化值) angle_priority_angles = [] angle_priority_radii = [] radius_priority_angles = [] radius_priority_radii = [] missing_angles = [] missing_radii = [] for i, (t_r_norm, t_theta_rad, r_norm, theta_rad, e_r_norm, e_theta_rad, dis, strategy) in enumerate(features): theta_deg = np.degrees(theta_rad) if r_norm > 0: if strategy == 1: angle_priority_angles.append(theta_deg) angle_priority_radii.append(r_norm) elif strategy == 2: radius_priority_angles.append(theta_deg) radius_priority_radii.append(r_norm) else: missing_angles.append(np.degrees(t_theta_rad)) missing_radii.append(t_r_norm) if angle_priority_angles: axes[1].scatter(angle_priority_angles, angle_priority_radii, c='cyan', s=20, label='角度优先', alpha=0.7, edgecolors='black') if radius_priority_angles: axes[1].scatter(radius_priority_angles, radius_priority_radii, c='yellow', s=20, label='半径优先', alpha=0.7, edgecolors='black') if missing_angles: axes[1].scatter(missing_angles, missing_radii, c='red', s=20, label='缺失点', alpha=0.7, marker='x') axes[1].legend(loc='upper right', fontsize=9) axes[1].set_xlim(-10, 370) axes[1].set_ylim(0, 2.0) # 归一化半径范围 plt.tight_layout() plt.savefig(output_path, dpi=150, bbox_inches='tight') plt.close() print(f"✅ 可视化图像已保存:{output_path}") return output_path def visualize_feature_detail(features, output_path='feature_detail.png'): """可视化 120 维特征的详细信息(适配规范化特征)""" n_samples = len(features) # 🔧 提取规范化特征 t_r_norm_vals = [f[0] for f in features] t_theta_rad_vals = [f[1] for f in features] r_norm_vals = [f[2] for f in features] theta_rad_vals = [f[3] for f in features] dis_vals = [f[6] for f in features] strategy_vals = [f[7] for f in features] # 转换为度数用于绘图 t_theta_deg_vals = [np.degrees(t) for t in t_theta_rad_vals] theta_deg_vals = [np.degrees(t) for t in theta_rad_vals] fig, axes = plt.subplots(2, 2, figsize=(14, 10)) angle_priority_mask = [s == 1 for s in strategy_vals] radius_priority_mask = [s == 2 for s in strategy_vals] # 1. 理论半径 vs 实际半径(归一化) axes[0, 0].plot(t_theta_deg_vals, t_r_norm_vals, 'b--', linewidth=1, label='理论半径 (归一化)', alpha=0.6) if any(angle_priority_mask): axes[0, 0].scatter([t for i, t in enumerate(theta_deg_vals) if angle_priority_mask[i]], [r for i, r in enumerate(r_norm_vals) if angle_priority_mask[i]], c='cyan', s=15, label='角度优先', alpha=0.7, edgecolors='black') if any(radius_priority_mask): axes[0, 0].scatter([t for i, t in enumerate(theta_deg_vals) if radius_priority_mask[i]], [r for i, r in enumerate(r_norm_vals) if radius_priority_mask[i]], c='yellow', s=15, label='半径优先', alpha=0.7, edgecolors='black') axes[0, 0].set_xlabel('角度 (°)') axes[0, 0].set_ylabel('归一化半径 (r/a)') axes[0, 0].set_title('半径对比(归一化,区分选择策略)') axes[0, 0].legend(fontsize=8) axes[0, 0].grid(alpha=0.3) # 2. 半径误差(归一化) radius_errors = [abs(r - t) if r > 0 else t for t, r in zip(t_r_norm_vals, r_norm_vals)] axes[0, 1].bar(t_theta_deg_vals, radius_errors, width=2.5, color='orange', alpha=0.7) axes[0, 1].axhline(y=RADIUS_DIFF_THRESHOLD / 100, color='red', linestyle='--', label=f'阈值 (归一化)', alpha=0.6) axes[0, 1].set_xlabel('角度 (°)') axes[0, 1].set_ylabel('归一化半径误差') axes[0, 1].set_title('半径误差分布(归一化)') axes[0, 1].legend(fontsize=8) axes[0, 1].grid(alpha=0.3, axis='y') # # 3. 相邻点距离 dis # axes[1, 0].bar(t_theta_deg_vals, dis_vals, width=2.5, color='purple', alpha=0.7) # axes[1, 0].axhline(y=20, color='red', linestyle='--', label='阈值=20', alpha=0.6) # axes[1, 0].set_xlabel('角度 (°)') # axes[1, 0].set_ylabel('相邻点距离 (像素)') # axes[1, 0].set_title('相邻采样点欧氏距离') # axes[1, 0].legend(fontsize=8) # axes[1, 0].grid(alpha=0.3, axis='y') # 4. 特征统计 valid_count = sum(1 for r in r_norm_vals if r > 0) missing_count = n_samples - valid_count angle_priority_count = sum(1 for s in strategy_vals if s == 1) radius_priority_count = sum(1 for s in strategy_vals if s == 2) avg_error = np.mean([abs(r - t) for t, r in zip(t_r_norm_vals, r_norm_vals) if r > 0]) if valid_count > 0 else 0 max_dis = np.max(dis_vals) if dis_vals else 0 stats_text = f""" 采样总数:{n_samples} ✅ 角度优先:{angle_priority_count} ({angle_priority_count / n_samples * 100:.1f}%) ✅ 半径优先:{radius_priority_count} ({radius_priority_count / n_samples * 100:.1f}%) ❌ 缺失点:{missing_count} ({missing_count / n_samples * 100:.1f}%) 平均归一化误差:{avg_error:.4f} 最大相邻距离:{max_dis:.2f} 像素 """ axes[1, 1].axis('off') axes[1, 1].text(0.5, 0.5, stats_text, fontsize=11, ha='center', va='center', bbox=dict(facecolor='lightblue', alpha=0.3, boxstyle='round')) axes[1, 1].set_title('特征统计摘要(归一化)') plt.tight_layout() plt.savefig(output_path, dpi=150, bbox_inches='tight') plt.close() print(f"✅ 特征详情图已保存:{output_path}") return output_path # ================= 6. 单图像处理 ================= def process_single_image_polar(img, image_path=None, output_dir=None, visualize=False, n_samples=N_SAMPLES): """处理单张图像""" if image_path is not None: img = cv2.imread(image_path) base_name = Path(image_path).stem if img is None: print(f"❌ 无法读取图像:{image_path}") return None gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # blur = cv2.GaussianBlur(gray, (5, 5), 0) _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU) skeleton_bool = skeletonize(binary // 255) skeleton_mask = (skeleton_bool * 255).astype(np.uint8) ellipse_params, skeleton_points = fit_ellipse_from_skeleton(skeleton_mask) if ellipse_params is None: # print(f"❌ 椭圆拟合失败:{image_path}") # length = 12 # random_str = ''.join(random.choices(string.ascii_letters + string.digits, k=length)) # cv2.imwrite(f"/path/to/circle_id/circle_output/augment2/fail_elipse_{random_str}.png", img) # cv2.imwrite(f"/path/to/circle_id/circle_output/augment2/fail_elipse_{random_str}_bin.png", binary) return None features, matched_points = extract_polar_ordered_features( skeleton_mask, ellipse_params, n_samples=n_samples ) if visualize: vis_path = os.path.join(output_dir, f'{base_name}_polar_sampling.png') visualize_polar_sampling(img, skeleton_mask, ellipse_params, features, matched_points, vis_path) detail_path = os.path.join(output_dir, f'{base_name}_feature_detail.png') visualize_feature_detail(features, detail_path) report = {} if output_dir is not None: # 🔧 保存特征(规范化格式) features_path = os.path.join(output_dir, f'{base_name}_features.npy') np.save(features_path, np.array(features, dtype=np.float32)) # 🔧 保存 matched_points 坐标 matched_path = os.path.join(output_dir, f'{base_name}_matched_points.npy') np.save(matched_path, np.array(matched_points, dtype=object)) report = { 'image_path': image_path, 'ellipse_params': { 'cx': float(ellipse_params['cx']), 'cy': float(ellipse_params['cy']), 'MA': float(ellipse_params['MA']), 'ma': float(ellipse_params['ma']), 'angle': float(ellipse_params['angle']), 'fit_error': float(ellipse_params['fit_error']) }, 'n_samples': n_samples, 'angle_tolerance': ANGLE_TOLERANCE, 'radius_diff_threshold': RADIUS_DIFF_THRESHOLD, 'matched_count': sum(1 for mp in matched_points if mp is not None), 'missing_count': sum(1 for mp in matched_points if mp is None), 'angle_priority_count': sum(1 for f in features if f[7] == 1), 'radius_priority_count': sum(1 for f in features if f[7] == 2), 'features_shape': [n_samples, 8], 'feature_names': ['t_r_norm', 't_theta_rad', 'r_norm', 'theta_rad', 'e_r_norm', 'e_theta_rad', 'dis', 'strategy'], 'feature_normalization': { 'radius': 'divided_by_semi_major_axis (a)', 'angle': 'degrees_to_radians' }, 'strategy_legend': {0: '无匹配', 1: '角度优先', 2: '半径优先'}, 'output_files': { 'features': features_path, 'matched_points': matched_path, # 🔧 新增 'visualization': os.path.join(output_dir, f'{base_name}_polar_sampling.png') if visualize else None, 'detail': os.path.join(output_dir, f'{base_name}_feature_detail.png') if visualize else None } } report_path = os.path.join(output_dir, f'{base_name}_report.json') with open(report_path, 'w') as f: json.dump(report, f, indent=2) return { 'features': np.array(features, dtype=np.float32), #120*8的特征 'matched_points': matched_points, # 🔧 返回原始坐标 'ellipse_params': ellipse_params, 'report': report } # ================= 7. 批量处理文件夹 ================= def process_folder_polar(input_folder, output_folder, visualize=False, n_samples=N_SAMPLES, file_extensions=None): """批量处理文件夹""" if file_extensions is None: file_extensions = ['.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff'] os.makedirs(output_folder, exist_ok=True) image_files = [] for ext in file_extensions: image_files.extend(Path(input_folder).glob(f'*{ext}')) image_files.extend(Path(input_folder).glob(f'*{ext.upper()}')) image_files = list(set(image_files)) image_files.sort() if len(image_files) == 0: print(f"❌ 在 {input_folder} 中未找到图片文件") return None print("=" * 70) print(f"批量处理:极坐标有序特征提取 (顺时针 + 规范化)") print(f" 输入:{input_folder}") print(f" 输出:{output_folder}") print(f" 图片数:{len(image_files)}") print(f" 采样数:{n_samples} (每 {360 / n_samples}°, 顺时针)") print(f" 角度容差:±{ANGLE_TOLERANCE}°") print(f" 半径差异阈值:{RADIUS_DIFF_THRESHOLD} 像素") print(f" 特征规范化:角度→弧度,半径→除以长半轴") print("=" * 70) results = [] success_count = 0 for i, image_path in enumerate(image_files): print(f"\n[{i + 1}/{len(image_files)}] {image_path.name}") try: result = process_single_image_polar(str(image_path), output_folder, visualize, n_samples) if result: results.append(result) success_count += 1 report = result['report'] print(f" ✅ 椭圆:MA={report['ellipse_params']['MA']:.1f}, " f"ma={report['ellipse_params']['ma']:.1f}, " f"误差={report['ellipse_params']['fit_error']:.2f}") print(f" 📊 匹配:{report['matched_count']}/{n_samples} " f"({report['matched_count'] / n_samples * 100:.1f}%)") print(f" 角度优先:{report['angle_priority_count']}, " f"半径优先:{report['radius_priority_count']}") else: print(f" ❌ 处理失败") except Exception as e: print(f" ❌ 错误:{e}") import traceback traceback.print_exc() summary = { 'input_folder': str(input_folder), 'output_folder': str(output_folder), 'total_images': len(image_files), 'success_count': success_count, 'success_rate': success_count / len(image_files) if len(image_files) > 0 else 0.0, 'n_samples': n_samples, 'angle_tolerance': ANGLE_TOLERANCE, 'radius_diff_threshold': RADIUS_DIFF_THRESHOLD, 'normalization': { 'radius': 'divided_by_semi_major_axis', 'angle': 'degrees_to_radians' }, 'results': [] } for result in results: report = result['report'] summary['results'].append({ 'image': Path(report['image_path']).name, 'ellipse': report['ellipse_params'], 'matched_count': report['matched_count'], 'missing_count': report['missing_count'], 'angle_priority_count': report['angle_priority_count'], 'radius_priority_count': report['radius_priority_count'] }) summary_path = os.path.join(output_folder, 'batch_summary.json') with open(summary_path, 'w') as f: json.dump(summary, f, indent=2) print("\n" + "=" * 70) print(f"批量完成!成功 {success_count}/{len(image_files)}") print(f"汇总报告:{summary_path}") print("=" * 70) return summary # ================= 8. 主函数 ================= if __name__ == "__main__": import sys print("=" * 70) print("极坐标有序特征提取系统 v3.0") print("优化:顺时针采样 + 特征规范化 (角度→弧度,半径→r/a) + 保留 matched_points") print("=" * 70) if len(sys.argv) > 1: input_path = sys.argv[1] else: input_path = DEFAULT_INPUT if len(sys.argv) > 2: output_folder = sys.argv[2] else: output_folder = DEFAULT_OUTPUT if os.path.isfile(input_path): print(f"\n📷 单图像模式:{input_path}") os.makedirs(output_folder, exist_ok=True) result = process_single_image_polar(input_path, output_folder, visualize=False) if result: features = result['features'] print(f"\n✅ 特征提取完成!") print(f" 特征维度:{features.shape}") print( f" 特征字段:['t_r_norm', 't_theta_rad', 'r_norm', 'theta_rad', 'e_r_norm', 'e_theta_rad', 'dis', 'strategy']") print(f" 规范化:角度→弧度,半径→除以长半轴 (a)") print(f" 匹配率:{result['report']['matched_count']}/120") print(f" matched_points 坐标已保存") else: print("\n❌ 处理失败") elif os.path.isdir(input_path): print(f"\n📁 批量文件夹模式:{input_path}") summary = process_folder_polar(input_path, output_folder, visualize=False) if summary: print(f"\n✅ 批量完成!成功 {summary['success_count']}/{summary['total_images']}") else: print(f"❌ 路径不存在:{input_path}") print("\n使用方法:") print(" python polar_order.py # 默认文件夹") print(" python polar_order.py /path/to/images # 指定输入") print(" python polar_order.py image.png # 单张图像") print(" python polar_order.py /in /out # 指定输入输出")