import traceback from typing import List, Dict, Any import cv2 import numpy as np import config from config import logger, DLIB_AVAILABLE if DLIB_AVAILABLE: import mediapipe as mp class FacialFeatureAnalyzer: """五官分析器""" def __init__(self): self.face_mesh = None if DLIB_AVAILABLE: try: # 初始化MediaPipe Face Mesh mp_face_mesh = mp.solutions.face_mesh self.face_mesh = mp_face_mesh.FaceMesh( static_image_mode=True, max_num_faces=1, refine_landmarks=True, min_detection_confidence=0.5, min_tracking_confidence=0.5 ) logger.info("MediaPipe face landmark detector loaded successfully") except Exception as e: logger.error(f"Failed to load MediaPipe model: {e}") def analyze_facial_features( self, face_image: np.ndarray, face_box: List[int] ) -> Dict[str, Any]: """ 分析五官特征 :param face_image: 人脸图像 :param face_box: 人脸边界框 [x1, y1, x2, y2] :return: 五官分析结果 """ if not DLIB_AVAILABLE or self.face_mesh is None: return self._basic_facial_analysis(face_image) try: # MediaPipe需要RGB图像 rgb_image = cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB) # 检测关键点 results = self.face_mesh.process(rgb_image) if not results.multi_face_landmarks: logger.warning("No facial landmarks detected") return self._basic_facial_analysis(face_image) # 获取第一个面部的关键点 face_landmarks = results.multi_face_landmarks[0] # 将MediaPipe的468个关键点转换为类似dlib 68点的格式 points = self._convert_mediapipe_to_dlib_format(face_landmarks, face_image.shape) return self._analyze_features_from_landmarks(points, face_image.shape) except Exception as e: logger.error(f"Facial feature analysis failed: {e}") traceback.print_exc() # ← 打印完整堆栈，包括确切行号 return self._basic_facial_analysis(face_image) def _convert_mediapipe_to_dlib_format(self, face_landmarks, image_shape): """ 将MediaPipe的468个关键点转换为类似dlib 68点的格式 MediaPipe到dlib的关键点映射 """ h, w = image_shape[:2] # MediaPipe关键点索引到dlib 68点的映射 # 这个映射基于MediaPipe Face Mesh的标准索引 mediapipe_to_dlib_map = { # 面部轮廓 (0-16) 0: 234, # 下巴最低点 1: 132, # 右脸颊下 2: 172, # 右脸颊 3: 136, # 右脸颊上 4: 150, # 右颧骨 5: 149, # 右太阳穴 6: 176, # 右额头边缘 7: 148, # 右额头 8: 152, # 额头中央 9: 377, # 左额头 10: 400, # 左额头边缘 11: 378, # 左太阳穴 12: 379, # 左颧骨 13: 365, # 左脸颊上 14: 397, # 左脸颊 15: 361, # 左脸颊下 16: 454, # 下巴左侧 # 右眉毛 (17-21) 17: 70, # 右眉毛外端 18: 63, # 右眉毛 19: 105, # 右眉毛 20: 66, # 右眉毛 21: 107, # 右眉毛内端 # 左眉毛 (22-26) 22: 336, # 左眉毛内端 23: 296, # 左眉毛 24: 334, # 左眉毛 25: 293, # 左眉毛 26: 300, # 左眉毛外端 # 鼻梁 (27-30) 27: 168, # 鼻梁顶 28: 8, # 鼻梁 29: 9, # 鼻梁 30: 10, # 鼻梁底 # 鼻翼 (31-35) 31: 151, # 右鼻翼 32: 134, # 右鼻孔 33: 2, # 鼻尖 34: 363, # 左鼻孔 35: 378, # 左鼻翼 # 右眼 (36-41) 36: 33, # 右眼外角 37: 7, # 右眼上眼睑 38: 163, # 右眼上眼睑 39: 144, # 右眼内角 40: 145, # 右眼下眼睑 41: 153, # 右眼下眼睑 # 左眼 (42-47) 42: 362, # 左眼内角 43: 382, # 左眼上眼睑 44: 381, # 左眼上眼睑 45: 380, # 左眼外角 46: 374, # 左眼下眼睑 47: 373, # 左眼下眼睑 # 嘴部轮廓 (48-67) 48: 78, # 右嘴角 49: 95, # 右上唇 50: 88, # 上唇右侧 51: 178, # 上唇中央右 52: 87, # 上唇中央 53: 14, # 上唇中央左 54: 317, # 上唇左侧 55: 318, # 左上唇 56: 308, # 左嘴角 57: 324, # 左下唇 58: 318, # 下唇左侧 59: 16, # 下唇中央左 60: 17, # 下唇中央 61: 18, # 下唇中央右 62: 200, # 下唇右侧 63: 199, # 右下唇 64: 175, # 右嘴角内 65: 84, # 上唇内右 66: 17, # 下唇内中央 67: 314, # 上唇内左 } # 转换关键点 points = [] for i in range(68): if i in mediapipe_to_dlib_map: mp_idx = mediapipe_to_dlib_map[i] if mp_idx < len(face_landmarks.landmark): landmark = face_landmarks.landmark[mp_idx] x = int(landmark.x * w) y = int(landmark.y * h) points.append((x, y)) else: # 如果索引超出范围，使用默认位置 points.append((w//2, h//2)) else: # 如果没有映射，使用默认位置 points.append((w//2, h//2)) return points def _analyze_features_from_landmarks( self, landmarks: List[tuple], image_shape: tuple ) -> Dict[str, Any]: """基于68个关键点分析五官""" try: # 定义各部位的关键点索引 jawline = landmarks[0:17] # 下颌线 left_eyebrow = landmarks[17:22] # 左眉毛 right_eyebrow = landmarks[22:27] # 右眉毛 nose = landmarks[27:36] # 鼻子 left_eye = landmarks[36:42] # 左眼 right_eye = landmarks[42:48] # 右眼 mouth = landmarks[48:68] # 嘴巴 # 计算各部位得分 (简化版，实际应用需要更复杂的算法) scores = { "eyes": self._score_eyes(left_eye, right_eye, image_shape), "nose": self._score_nose(nose, image_shape), "mouth": self._score_mouth(mouth, image_shape), "eyebrows": self._score_eyebrows( left_eyebrow, right_eyebrow, image_shape ), "jawline": self._score_jawline(jawline, image_shape), } # 计算总体协调性 harmony_score = self._calculate_harmony_new(landmarks, image_shape) # 温和上调整体协调性分数（与颜值类似的拉升策略） harmony_score = self._adjust_harmony_score(harmony_score) return { "facial_features": scores, "harmony_score": round(harmony_score, 2), "overall_facial_score": round(sum(scores.values()) / len(scores), 2), "analysis_method": "mediapipe_landmarks", } except Exception as e: logger.error(f"Landmark analysis failed: {e}") return self._basic_facial_analysis(None) def _adjust_harmony_score(self, score: float) -> float: """整体协调性分值温和拉升：当低于阈值时往阈值靠拢一点。""" try: if not getattr(config, "HARMONY_ADJUST_ENABLED", False): return round(float(score), 2) thr = float(getattr(config, "HARMONY_ADJUST_THRESHOLD", 8.0)) gamma = float(getattr(config, "HARMONY_ADJUST_GAMMA", 0.5)) gamma = max(0.0001, min(1.0, gamma)) s = float(score) if s < thr: s = thr - gamma * (thr - s) return round(min(10.0, max(0.0, s)), 2) except Exception: try: return round(float(score), 2) except Exception: return 6.21 def _score_eyes( self, left_eye: List[tuple], right_eye: List[tuple], image_shape: tuple ) -> float: """眼部评分""" try: # 计算眼部对称性和大小 left_width = abs(left_eye[3][0] - left_eye[0][0]) right_width = abs(right_eye[3][0] - right_eye[0][0]) # 计算眼部高度 left_height = abs(left_eye[1][1] - left_eye[5][1]) right_height = abs(right_eye[1][1] - right_eye[5][1]) # 对称性评分 - 宽度对称性 width_symmetry = 1 - min( abs(left_width - right_width) / max(left_width, right_width), 0.5 ) # 高度对称性 height_symmetry = 1 - min( abs(left_height - right_height) / max(left_height, right_height), 0.5 ) # 大小适中性评分 (相对于脸部宽度) - 调整理想比例 avg_eye_width = (left_width + right_width) / 2 face_width = image_shape[1] ideal_ratio = 0.08 # 调整理想比例，原来0.15太大 size_score = max( 0, 1 - abs(avg_eye_width / face_width - ideal_ratio) / ideal_ratio ) # 眼部长宽比评分 avg_eye_height = (left_height + right_height) / 2 aspect_ratio = avg_eye_width / max(avg_eye_height, 1) # 避免除零 ideal_aspect = 3.0 # 理想长宽比 aspect_score = max(0, 1 - abs(aspect_ratio - ideal_aspect) / ideal_aspect) final_score = ( width_symmetry * 0.3 + height_symmetry * 0.3 + size_score * 0.25 + aspect_score * 0.15 ) * 10 return round(max(0, min(10, final_score)), 2) except: return 6.21 def _score_nose(self, nose: List[tuple], image_shape: tuple) -> float: """鼻部评分""" try: # 鼻子关键点 nose_tip = nose[3] # 鼻尖 nose_bridge_top = nose[0] # 鼻梁顶部 left_nostril = nose[1] right_nostril = nose[5] # 计算鼻子的直线度 (鼻梁是否挺直) straightness = 1 - min( abs(nose_tip[0] - nose_bridge_top[0]) / (image_shape[1] * 0.1), 1.0 ) # 鼻宽评分 - 使用鼻翼宽度 nose_width = abs(right_nostril[0] - left_nostril[0]) face_width = image_shape[1] ideal_nose_ratio = 0.06 # 调整理想比例 width_score = max( 0, 1 - abs(nose_width / face_width - ideal_nose_ratio) / ideal_nose_ratio, ) # 鼻子长度评分 nose_length = abs(nose_tip[1] - nose_bridge_top[1]) face_height = image_shape[0] ideal_length_ratio = 0.08 length_score = max( 0, 1 - abs(nose_length / face_height - ideal_length_ratio) / ideal_length_ratio, ) final_score = ( straightness * 0.4 + width_score * 0.35 + length_score * 0.25 ) * 10 return round(max(0, min(10, final_score)), 2) except: return 6.21 def _score_mouth(self, mouth: List[tuple], image_shape: tuple) -> float: """嘴部评分 - 大幅优化，更宽松的评分标准""" try: # 嘴角点 left_corner = mouth[0] # 左嘴角 right_corner = mouth[6] # 右嘴角 # 上唇和下唇中心点 upper_lip_center = mouth[3] # 上唇中心 lower_lip_center = mouth[9] # 下唇中心 # 基础分数，避免过低 base_score = 6.0 # 1. 嘴宽评分 - 更宽松的标准 mouth_width = abs(right_corner[0] - left_corner[0]) face_width = image_shape[1] mouth_ratio = mouth_width / face_width # 设置更宽的合理范围 (0.04-0.15) if 0.04 <= mouth_ratio <= 0.15: width_score = 1.0 # 在合理范围内就给满分 elif mouth_ratio < 0.04: width_score = max(0.3, mouth_ratio / 0.04) # 太小时渐减 else: width_score = max(0.3, 0.15 / mouth_ratio) # 太大时渐减 # 2. 唇厚度评分 - 简化并放宽标准 lip_thickness = abs(lower_lip_center[1] - upper_lip_center[1]) # 只要厚度不是极端值就给高分 if lip_thickness > 3: # 像素值，有一定厚度 thickness_score = min(1.0, lip_thickness / 25) # 25像素为满分 else: thickness_score = 0.5 # 太薄给中等分数 # 3. 嘴部对称性评分 - 更宽松 mouth_center_x = (left_corner[0] + right_corner[0]) / 2 face_center_x = image_shape[1] / 2 center_deviation = abs(mouth_center_x - face_center_x) / face_width if center_deviation < 0.02: # 偏差小于2% symmetry_score = 1.0 elif center_deviation < 0.05: # 偏差小于5% symmetry_score = 0.8 else: symmetry_score = max(0.5, 1 - center_deviation * 10) # 最低0.5分 # 4. 嘴唇形状评分 - 简化 # 检查嘴角是否在合理位置 corner_height_diff = abs(left_corner[1] - right_corner[1]) if corner_height_diff < face_width * 0.02: # 嘴角高度差异小 shape_score = 1.0 else: shape_score = max(0.6, 1 - corner_height_diff / (face_width * 0.02)) # 5. 综合评分 - 调整权重，给基础分更大权重 feature_score = ( width_score * 0.3 + thickness_score * 0.25 + symmetry_score * 0.25 + shape_score * 0.2 ) # 最终分数 = 基础分 + 特征分奖励 final_score = base_score + feature_score * 4 # 最高10分 return round(max(4.0, min(10, final_score)), 2) # 最低4分，最高10分 except Exception as e: return 6.21 def _score_eyebrows( self, left_brow: List[tuple], right_brow: List[tuple], image_shape: tuple ) -> float: """眉毛评分 - 改进算法""" try: # 计算眉毛长度 left_length = abs(left_brow[-1][0] - left_brow[0][0]) right_length = abs(right_brow[-1][0] - right_brow[0][0]) # 长度对称性 length_symmetry = 1 - min( abs(left_length - right_length) / max(left_length, right_length), 0.5 ) # 计算眉毛拱形 - 改进方法 left_peak_y = min([p[1] for p in left_brow]) # 眉峰(y坐标最小) left_ends_y = (left_brow[0][1] + left_brow[-1][1]) / 2 # 眉毛两端平均高度 left_arch = max(0, left_ends_y - left_peak_y) # 拱形高度 right_peak_y = min([p[1] for p in right_brow]) right_ends_y = (right_brow[0][1] + right_brow[-1][1]) / 2 right_arch = max(0, right_ends_y - right_peak_y) # 拱形对称性 arch_symmetry = 1 - min( abs(left_arch - right_arch) / max(left_arch, right_arch, 1), 0.5 ) # 眉形适中性评分 avg_arch = (left_arch + right_arch) / 2 face_height = image_shape[0] ideal_arch_ratio = 0.015 # 理想拱形比例 arch_ratio = avg_arch / face_height arch_score = max( 0, 1 - abs(arch_ratio - ideal_arch_ratio) / ideal_arch_ratio ) # 眉毛浓密度(通过点的密集程度估算) density_score = min(1.0, (len(left_brow) + len(right_brow)) / 10) final_score = ( length_symmetry * 0.3 + arch_symmetry * 0.3 + arch_score * 0.25 + density_score * 0.15 ) * 10 return round(max(0, min(10, final_score)), 2) except: return 6.21 def _score_jawline(self, jawline: List[tuple], image_shape: tuple) -> float: """下颌线评分 - 改进算法""" try: jaw_points = [(p[0], p[1]) for p in jawline] # 关键点 left_jaw = jaw_points[2] # 左下颌角 jaw_tip = jaw_points[8] # 下巴尖 right_jaw = jaw_points[14] # 右下颌角 # 对称性评分 - 改进计算 left_dist = ( (left_jaw[0] - jaw_tip[0]) ** 2 + (left_jaw[1] - jaw_tip[1]) ** 2 ) ** 0.5 right_dist = ( (right_jaw[0] - jaw_tip[0]) ** 2 + (right_jaw[1] - jaw_tip[1]) ** 2 ) ** 0.5 symmetry = 1 - min( abs(left_dist - right_dist) / max(left_dist, right_dist), 0.5 ) # 下颌角度评分 left_angle_y = abs(left_jaw[1] - jaw_tip[1]) right_angle_y = abs(right_jaw[1] - jaw_tip[1]) avg_angle = (left_angle_y + right_angle_y) / 2 # 理想的下颌角度 face_height = image_shape[0] ideal_angle_ratio = 0.08 angle_ratio = avg_angle / face_height angle_score = max( 0, 1 - abs(angle_ratio - ideal_angle_ratio) / ideal_angle_ratio ) # 下颌线清晰度(通过点间距离变化评估) smoothness_score = 0.8 # 简化处理，可以根据实际需要改进 final_score = ( symmetry * 0.4 + angle_score * 0.35 + smoothness_score * 0.25 ) * 10 return round(max(0, min(10, final_score)), 2) except: return 6.21 def _calculate_harmony(self, landmarks: List[tuple], image_shape: tuple) -> float: """计算五官协调性""" try: # 黄金比例检测 (简化版) face_height = max([p[1] for p in landmarks]) - min( [p[1] for p in landmarks] ) face_width = max([p[0] for p in landmarks]) - min([p[0] for p in landmarks]) # 理想比例约为1.618 ratio = face_height / face_width if face_width > 0 else 1 golden_ratio = 1.618 harmony = 1 - abs(ratio - golden_ratio) / golden_ratio return max(0, min(10, harmony * 10)) except: return 6.21 def _calculate_harmony_new( self, landmarks: List[tuple], image_shape: tuple ) -> float: """ 计算五官协调性 - 优化版本 基于多个美学比例和对称性指标 """ try: logger.info(f"face landmarks={len(landmarks)}") if len(landmarks) < 68: # 假设使用68点面部关键点 return 6.21 # 转换为numpy数组便于计算 points = np.array(landmarks) # 1. 面部基础测量 face_measurements = self._get_face_measurements(points) # 2. 计算多个协调性指标 scores = [] # 黄金比例评分 (权重: 20%) golden_score = self._calculate_golden_ratios(face_measurements) logger.info(f"Golden ratio score={golden_score}") scores.append(("golden_ratio", golden_score, 0.10)) # 对称性评分 (权重: 25%) symmetry_score = self._calculate_facial_symmetry(face_measurements, points) logger.info(f"Symmetry score={symmetry_score}") scores.append(("symmetry", symmetry_score, 0.40)) # 三庭五眼比例 (权重: 20%) proportion_score = self._calculate_classical_proportions(face_measurements) logger.info(f"Three courts five eyes ratio={proportion_score}") scores.append(("proportions", proportion_score, 0.05)) # 五官间距协调性 (权重: 15%) spacing_score = self._calculate_feature_spacing(face_measurements) logger.info(f"Facial feature spacing harmony={spacing_score}") scores.append(("spacing", spacing_score, 0)) # 面部轮廓协调性 (权重: 10%) contour_score = self._calculate_contour_harmony(points) logger.info(f"Facial contour harmony={contour_score}") scores.append(("contour", contour_score, 0.05)) # 眼鼻口比例协调性 (权重: 10%) feature_score = self._calculate_feature_proportions(face_measurements) logger.info(f"Eye-nose-mouth proportion harmony={feature_score}") scores.append(("features", feature_score, 0.40)) # 加权平均计算最终得分 final_score = sum(score * weight for _, score, weight in scores) logger.info(f"Weighted average final score={final_score}") return max(0, min(10, final_score)) except Exception as e: logger.error(f"Error calculating facial harmony: {e}") traceback.print_exc() # ← 打印完整堆栈，包括确切行号 return 6.21 def _get_face_measurements(self, points: np.ndarray) -> Dict[str, float]: """提取面部关键测量数据""" measurements = {} # 面部轮廓点 (0-16) face_contour = points[0:17] # 眉毛点 (17-26) left_eyebrow = points[17:22] right_eyebrow = points[22:27] # 眼睛点 (36-47) left_eye = points[36:42] right_eye = points[42:48] # 鼻子点 (27-35) nose = points[27:36] # 嘴巴点 (48-67) mouth = points[48:68] # 基础测量 measurements["face_width"] = np.max(face_contour[:, 0]) - np.min( face_contour[:, 0] ) measurements["face_height"] = np.max(points[:, 1]) - np.min(points[:, 1]) # 眼部测量 measurements["left_eye_width"] = np.max(left_eye[:, 0]) - np.min(left_eye[:, 0]) measurements["right_eye_width"] = np.max(right_eye[:, 0]) - np.min( right_eye[:, 0] ) measurements["eye_distance"] = np.min(right_eye[:, 0]) - np.max(left_eye[:, 0]) measurements["left_eye_center"] = np.mean(left_eye, axis=0) measurements["right_eye_center"] = np.mean(right_eye, axis=0) # 鼻部测量 measurements["nose_width"] = np.max(nose[:, 0]) - np.min(nose[:, 0]) measurements["nose_height"] = np.max(nose[:, 1]) - np.min(nose[:, 1]) measurements["nose_tip"] = points[33] # 鼻尖 # 嘴部测量 measurements["mouth_width"] = np.max(mouth[:, 0]) - np.min(mouth[:, 0]) measurements["mouth_height"] = np.max(mouth[:, 1]) - np.min(mouth[:, 1]) # 关键垂直距离 measurements["forehead_height"] = measurements["left_eye_center"][1] - np.min( points[:, 1] ) measurements["middle_face_height"] = ( measurements["nose_tip"][1] - measurements["left_eye_center"][1] ) measurements["lower_face_height"] = ( np.max(points[:, 1]) - measurements["nose_tip"][1] ) return measurements def _calculate_golden_ratios(self, measurements: Dict[str, float]) -> float: """计算黄金比例相关得分""" golden_ratio = 1.618 scores = [] # 面部长宽比 if measurements["face_width"] > 0: face_ratio = measurements["face_height"] / measurements["face_width"] score = 1 - abs(face_ratio - golden_ratio) / golden_ratio scores.append(max(0, score)) # 上中下三庭比例 total_height = ( measurements["forehead_height"] + measurements["middle_face_height"] + measurements["lower_face_height"] ) if total_height > 0: upper_ratio = measurements["forehead_height"] / total_height middle_ratio = measurements["middle_face_height"] / total_height lower_ratio = measurements["lower_face_height"] / total_height # 理想比例约为 1:1:1 ideal_ratio = 1 / 3 upper_score = 1 - abs(upper_ratio - ideal_ratio) / ideal_ratio middle_score = 1 - abs(middle_ratio - ideal_ratio) / ideal_ratio lower_score = 1 - abs(lower_ratio - ideal_ratio) / ideal_ratio scores.extend( [max(0, upper_score), max(0, middle_score), max(0, lower_score)] ) return np.mean(scores) * 10 if scores else 7.0 def _calculate_facial_symmetry( self, measurements: Dict[str, float], points: np.ndarray ) -> float: """计算面部对称性""" # 计算面部中线 face_center_x = np.mean(points[:, 0]) # 检查左右对称的关键点对 symmetry_pairs = [ (17, 26), # 眉毛外端 (18, 25), # 眉毛 (19, 24), # 眉毛 (36, 45), # 眼角 (39, 42), # 眼角 (31, 35), # 鼻翼 (48, 54), # 嘴角 (4, 12), # 面部轮廓 (5, 11), # 面部轮廓 (6, 10), # 面部轮廓 ] symmetry_scores = [] for left_idx, right_idx in symmetry_pairs: if left_idx < len(points) and right_idx < len(points): left_point = points[left_idx] right_point = points[right_idx] # 计算到中线的距离差异 left_dist = abs(left_point[0] - face_center_x) right_dist = abs(right_point[0] - face_center_x) # 垂直位置差异 vertical_diff = abs(left_point[1] - right_point[1]) # 对称性得分 if left_dist + right_dist > 0: horizontal_symmetry = 1 - abs(left_dist - right_dist) / ( left_dist + right_dist ) vertical_symmetry = 1 - vertical_diff / measurements.get( "face_height", 100 ) symmetry_scores.append( (horizontal_symmetry + vertical_symmetry) / 2 ) return np.mean(symmetry_scores) * 10 if symmetry_scores else 7.0 def _calculate_classical_proportions(self, measurements: Dict[str, float]) -> float: """计算经典美学比例 (三庭五眼等)""" scores = [] # 五眼比例检测 if measurements["face_width"] > 0: eye_width_avg = ( measurements["left_eye_width"] + measurements["right_eye_width"] ) / 2 ideal_eye_count = 5 # 理想情况下面宽应该等于5个眼宽 actual_eye_count = ( measurements["face_width"] / eye_width_avg if eye_width_avg > 0 else 5 ) eye_proportion_score = ( 1 - abs(actual_eye_count - ideal_eye_count) / ideal_eye_count ) scores.append(max(0, eye_proportion_score)) # 眼间距比例 if measurements.get("left_eye_width", 0) > 0: eye_spacing_ratio = ( measurements["eye_distance"] / measurements["left_eye_width"] ) ideal_spacing_ratio = 1.0 # 理想情况下眼间距约等于一个眼宽 spacing_score = ( 1 - abs(eye_spacing_ratio - ideal_spacing_ratio) / ideal_spacing_ratio ) scores.append(max(0, spacing_score)) # 鼻宽与眼宽比例 if ( measurements.get("left_eye_width", 0) > 0 and measurements.get("nose_width", 0) > 0 ): nose_eye_ratio = measurements["nose_width"] / measurements["left_eye_width"] ideal_nose_eye_ratio = 0.8 # 理想鼻宽约为眼宽的80% nose_score = ( 1 - abs(nose_eye_ratio - ideal_nose_eye_ratio) / ideal_nose_eye_ratio ) scores.append(max(0, nose_score)) return np.mean(scores) * 10 if scores else 7.0 def _calculate_feature_spacing(self, measurements: Dict[str, float]) -> float: """计算五官间距协调性""" scores = [] # 眼鼻距离协调性 eye_nose_distance = abs( measurements["left_eye_center"][1] - measurements["nose_tip"][1] ) if measurements.get("face_height", 0) > 0: eye_nose_ratio = eye_nose_distance / measurements["face_height"] ideal_ratio = 0.15 # 理想比例 score = 1 - abs(eye_nose_ratio - ideal_ratio) / ideal_ratio scores.append(max(0, score)) # 鼻嘴距离协调性 nose_mouth_distance = abs( measurements["nose_tip"][1] - np.mean([measurements.get("mouth_height", 0)]) ) if measurements.get("face_height", 0) > 0: nose_mouth_ratio = nose_mouth_distance / measurements["face_height"] ideal_ratio = 0.12 # 理想比例 score = 1 - abs(nose_mouth_ratio - ideal_ratio) / ideal_ratio scores.append(max(0, score)) return np.mean(scores) * 10 if scores else 7.0 def _calculate_contour_harmony(self, points: np.ndarray) -> float: """计算面部轮廓协调性""" try: face_contour = points[0:17] # 面部轮廓点 # 计算轮廓的平滑度 smoothness_scores = [] for i in range(1, len(face_contour) - 1): # 计算相邻三点形成的角度 p1, p2, p3 = face_contour[i - 1], face_contour[i], face_contour[i + 1] v1 = p1 - p2 v2 = p3 - p2 # 计算角度 cos_angle = np.dot(v1, v2) / ( np.linalg.norm(v1) * np.linalg.norm(v2) + 1e-8 ) angle = np.arccos(np.clip(cos_angle, -1, 1)) # 角度越接近平滑曲线越好 (避免过于尖锐的角度) smoothness = 1 - abs(angle - np.pi / 2) / (np.pi / 2) smoothness_scores.append(max(0, smoothness)) return np.mean(smoothness_scores) * 10 if smoothness_scores else 7.0 except: return 6.21 def _calculate_feature_proportions(self, measurements: Dict[str, float]) -> float: """计算眼鼻口等五官内部比例协调性""" scores = [] # 眼部比例 (长宽比) left_eye_ratio = measurements.get("left_eye_width", 1) / max( measurements.get("left_eye_width", 1) * 0.3, 1 ) right_eye_ratio = measurements.get("right_eye_width", 1) / max( measurements.get("right_eye_width", 1) * 0.3, 1 ) # 理想眼部长宽比约为3:1 ideal_eye_ratio = 3.0 left_eye_score = 1 - abs(left_eye_ratio - ideal_eye_ratio) / ideal_eye_ratio right_eye_score = 1 - abs(right_eye_ratio - ideal_eye_ratio) / ideal_eye_ratio scores.extend([max(0, left_eye_score), max(0, right_eye_score)]) # 嘴部比例 if measurements.get("mouth_height", 0) > 0: mouth_ratio = measurements["mouth_width"] / measurements["mouth_height"] ideal_mouth_ratio = 3.5 # 理想嘴部长宽比 mouth_score = 1 - abs(mouth_ratio - ideal_mouth_ratio) / ideal_mouth_ratio scores.append(max(0, mouth_score)) # 鼻部比例 if measurements.get("nose_height", 0) > 0: nose_ratio = measurements["nose_height"] / measurements["nose_width"] ideal_nose_ratio = 1.5 # 理想鼻部长宽比 nose_score = 1 - abs(nose_ratio - ideal_nose_ratio) / ideal_nose_ratio scores.append(max(0, nose_score)) return np.mean(scores) * 10 if scores else 7.0 def _basic_facial_analysis(self, face_image) -> Dict[str, Any]: """基础五官分析 (当dlib不可用时)""" return { "facial_features": { "eyes": 7.0, "nose": 7.0, "mouth": 7.0, "eyebrows": 7.0, "jawline": 7.0, }, "harmony_score": 7.0, "overall_facial_score": 7.0, "analysis_method": "basic_estimation", } def draw_facial_landmarks(self, face_image: np.ndarray) -> np.ndarray: """ 在人脸图像上绘制特征点 :param face_image: 人脸图像 :return: 带特征点标记的人脸图像 """ if not DLIB_AVAILABLE or self.face_mesh is None: # 如果没有可用的面部网格检测器，直接返回原图 return face_image.copy() try: # 复制原图用于绘制 annotated_image = face_image.copy() # MediaPipe需要RGB图像 rgb_image = cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB) # 检测关键点 results = self.face_mesh.process(rgb_image) if not results.multi_face_landmarks: logger.warning("No facial landmarks detected for drawing") return annotated_image # 获取第一个面部的关键点 face_landmarks = results.multi_face_landmarks[0] # 绘制所有关键点 h, w = face_image.shape[:2] for landmark in face_landmarks.landmark: x = int(landmark.x * w) y = int(landmark.y * h) # 绘制小圆点表示关键点 cv2.circle(annotated_image, (x, y), 1, (0, 255, 0), -1) # 绘制十字标记 cv2.line(annotated_image, (x-2, y), (x+2, y), (0, 255, 0), 1) cv2.line(annotated_image, (x, y-2), (x, y+2), (0, 255, 0), 1) return annotated_image except Exception as e: logger.error(f"Failed to draw facial landmarks: {e}") return face_image.copy()