Update app.py

app.py

@@ -4,6 +4,8 @@ from PIL import Image
 import numpy as np
 import cv2
 from transformers import AutoImageProcessor, AutoModelForImageClassification
+from skimage.feature import graycomatrix, graycoprops, local_binary_pattern
+from scipy import ndimage, stats
 
 # 加载多个检测模型
 models = {
@@ -144,6 +146,17 @@ def analyze_image_features(image):
                 patch = img_array[i:i+10, j:j+10]
                 local_color_variations.append(np.std(patch))
         features["local_color_variation"] = float(np.mean(local_color_variations))
+        
+        # 颜色分布的自然度 - 真实照片的颜色分布更自然
+        r_hist, _ = np.histogram(img_array[:,:,0], bins=256, range=(0, 256))
+        g_hist, _ = np.histogram(img_array[:,:,1], bins=256, range=(0, 256))
+        b_hist, _ = np.histogram(img_array[:,:,2], bins=256, range=(0, 256))
+        
+        # 计算颜色直方图的熵 - 真实照片通常熵值更高
+        r_entropy = stats.entropy(r_hist + 1e-10)  # 添加小值避免log(0)
+        g_entropy = stats.entropy(g_hist + 1e-10)
+        b_entropy = stats.entropy(b_hist + 1e-10)
+        features["color_entropy"] = float((r_entropy + g_entropy + b_entropy) / 3)
     
     # 边缘一致性分析
     edges = cv2.Canny(img_cv, 100, 200)
@@ -156,11 +169,15 @@ def analyze_image_features(image):
         sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
         edge_magnitude = np.sqrt(sobelx**2 + sobely**2)
         features["edge_variance"] = float(np.var(edge_magnitude))
+        
+        # 边缘方向分布 - 真实照片的边缘方向分布更自然
+        edge_direction = np.arctan2(sobely, sobelx) * 180 / np.pi
+        edge_dir_hist, _ = np.histogram(edge_direction[edge_magnitude > 30], bins=36, range=(-180, 180))
+        features["edge_direction_entropy"] = float(stats.entropy(edge_dir_hist + 1e-10))
     
     # 纹理分析 - 使用灰度共生矩阵
     if len(img_array.shape) == 3:
         gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
-        from skimage.feature import graycomatrix, graycoprops
         
         # 计算GLCM
         distances = [5]
@@ -174,6 +191,18 @@ def analyze_image_features(image):
         features["texture_energy"] = float(np.mean(graycoprops(glcm, 'energy')[0]))
         features["texture_dissimilarity"] = float(np.mean(graycoprops(glcm, 'dissimilarity')[0]))
         features["texture_ASM"] = float(np.mean(graycoprops(glcm, 'ASM')[0]))
+        
+        # 局部二值模式 (LBP) - 分析微观纹理
+        try:
+            radius = 3
+            n_points = 8 * radius
+            lbp = local_binary_pattern(gray, n_points, radius, method='uniform')
+            lbp_hist, _ = np.histogram(lbp, bins=n_points + 2, range=(0, n_points + 2))
+            lbp_hist = lbp_hist.astype(float) / sum(lbp_hist)
+            features["lbp_entropy"] = float(stats.entropy(lbp_hist + 1e-10))
+        except:
+            # 如果LBP分析失败，不添加这个特征
+            pass
     
     # 噪声分析
     if len(img_array.shape) == 3:
@@ -189,6 +218,15 @@ def analyze_image_features(image):
         noise_fft_shift = np.fft.fftshift(noise_fft)
         noise_magnitude = np.abs(noise_fft_shift)
         features["noise_spectrum_std"] = float(np.std(noise_magnitude))
+        
+        # 噪声的空间一致性 - AI生成图像的噪声空间分布通常不够自然
+        noise_blocks = []
+        block_size = 32
+        for i in range(0, noise.shape[0]-block_size, block_size):
+            for j in range(0, noise.shape[1]-block_size, block_size):
+                block = noise[i:i+block_size, j:j+block_size]
+                noise_blocks.append(np.mean(block))
+        features["noise_spatial_std"] = float(np.std(noise_blocks))
     
     # 对称性分析 - AI生成图像通常有更高的对称性
     if img_cv.shape[1] % 2 == 0:  # 确保宽度是偶数
@@ -228,6 +266,14 @@ def analyze_image_features(image):
         # 频率分布的自然度 - 真实照片通常有更自然的频率分布
         freq_std = np.std(magnitude)
         features["freq_std"] = float(freq_std)
+        
+        # 频率分布的各向异性 - 真实照片的频率分布通常更各向异性
+        freq_blocks = []
+        for angle in range(0, 180, 20):
+            mask = np.zeros_like(magnitude)
+            cv2.ellipse(mask, (center_w, center_h), (w//2, h//2), angle, -10, 10, 1, -1)
+            freq_blocks.append(np.mean(magnitude * mask))
+        features["freq_anisotropy"] = float(np.std(freq_blocks))
     
     # 尝试检测人脸
     try:
@@ -256,10 +302,31 @@ def analyze_image_features(image):
                 features["face_skin_std"] = np.mean([f["skin_std"] for f in face_features])
                 features["face_local_contrast"] = np.mean([f["skin_local_contrast"] for f in face_features])
                 features["face_symmetry"] = np.mean([f["face_symmetry"] for f in face_features])
+                
+                # 面部微表情分析
+                for i, (x, y, w, h) in enumerate(faces):
+                    face = gray[y:y+h, x:x+w]
+                    # 分析面部纹理的局部变化
+                    face_blocks = []
+                    block_size = 8
+                    for bi in range(0, face.shape[0]-block_size, block_size):
+                        for bj in range(0, face.shape[1]-block_size, block_size):
+                            block = face[bi:bi+block_size, bj:bj+block_size]
+                            face_blocks.append(np.std(block))
+                    if face_blocks:
+                        features[f"face_{i}_texture_variation"] = float(np.std(face_blocks))
     except:
         # 如果人脸检测失败，不添加人脸特征
         pass
     
+    # 分析物理一致性
+    physical_features = analyze_physical_consistency(img_cv)
+    features.update(physical_features)
+    
+    # 分析细节连贯性
+    detail_features = analyze_detail_coherence(img_cv)
+    features.update(detail_features)
+    
     # 分析衣物细节
     clothing_features = analyze_clothing_details(img_cv)
     features.update(clothing_features)
@@ -279,6 +346,137 @@ def analyze_face_symmetry(face):
             return 1 - float(np.mean(cv2.absdiff(left_half, right_half)) / 255)
     return 0.5  # 默认值
 
+def analyze_physical_consistency(image):
+    """分析图像中的物理一致性"""
+    features = {}
+    
+    try:
+        # 转换为灰度图
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image
+        
+        # 光影一致性分析
+        # 检测亮度梯度
+        sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+        sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+        gradient_magnitude = np.sqrt(sobelx**2 + sobely**2)
+        gradient_direction = np.arctan2(sobely, sobelx)
+        
+        # 分析梯度方向的一致性 - 真实照片的光影梯度方向更一致
+        # 将图像分成块，分析每个块的主要梯度方向
+        block_size = 32
+        gradient_dirs = []
+        for i in range(0, gray.shape[0]-block_size, block_size):
+            for j in range(0, gray.shape[1]-block_size, block_size):
+                block_gradient = gradient_direction[i:i+block_size, j:j+block_size]
+                block_magnitude = gradient_magnitude[i:i+block_size, j:j+block_size]
+                # 只考虑梯度幅值较大的像素
+                significant_gradients = block_gradient[block_magnitude > np.mean(block_magnitude)]
+                if len(significant_gradients) > 0:
+                    # 计算主要方向
+                    hist, _ = np.histogram(significant_gradients, bins=8, range=(-np.pi, np.pi))
+                    main_dir = np.argmax(hist)
+                    gradient_dirs.append(main_dir)
+        
+        if gradient_dirs:
+            # 计算主要方向的一致性
+            hist, _ = np.histogram(gradient_dirs, bins=8, range=(0, 8))
+            features["light_direction_consistency"] = float(np.max(hist) / max(sum(hist), 1))
+        
+        # 透视一致性分析
+        # 使用霍夫变换检测直线
+        edges = cv2.Canny(gray, 50, 150)
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50, minLineLength=50, maxLineGap=10)
+        
+        if lines is not None and len(lines) > 1:
+            # 分析消失点
+            vanishing_points = []
+            for i in range(len(lines)):
+                for j in range(i+1, len(lines)):
+                    x1, y1, x2, y2 = lines[i][0]
+                    x3, y3, x4, y4 = lines[j][0]
+                    
+                    # 计算两条线的交点（可能的消失点）
+                    d = (x1-x2)*(y3-y4) - (y1-y2)*(x3-x4)
+                    if abs(d) > 0.001:  # 避免平行线
+                        px = ((x1*y2 - y1*x2)*(x3-x4) - (x1-x2)*(x3*y4 - y3*x4)) / d
+                        py = ((x1*y2 - y1*x2)*(y3-y4) - (y1-y2)*(x3*y4 - y3*x4)) / d
+                        
+                        # 只考虑图像范围内或附近的交点
+                        img_diag = np.sqrt(gray.shape[0]**2 + gray.shape[1]**2)
+                        if -img_diag < px < 2*gray.shape[1] and -img_diag < py < 2*gray.shape[0]:
+                            vanishing_points.append((px, py))
+            
+            if vanishing_points:
+                # 分析消失点的聚集程度 - 真实照片的消失点通常更聚集
+                vp_x = [p[0] for p in vanishing_points]
+                vp_y = [p[1] for p in vanishing_points]
+                features["perspective_consistency"] = float(1 / (1 + np.std(vp_x) + np.std(vp_y)))
+    except:
+        # 如果分析失败，不添加物理一致性特征
+        pass
+    
+    return features
+
+def analyze_detail_coherence(image):
+    """分析图像细节的连贯性"""
+    features = {}
+    
+    try:
+        # 转换为灰度图
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image
+        
+        # 多尺度细节��析
+        scales = [3, 5, 9]
+        detail_levels = []
+        
+        for scale in scales:
+            # 使用不同尺度的拉普拉斯算子提取细节
+            laplacian = cv2.Laplacian(gray, cv2.CV_64F, ksize=scale)
+            abs_laplacian = np.abs(laplacian)
+            detail_levels.append(np.mean(abs_laplacian))
+        
+        # 计算细节随尺度变化的一致性 - 真实照片的细节随尺度变化更自然
+        if len(detail_levels) > 1:
+            features["detail_scale_consistency"] = float(np.std(detail_levels) / max(np.mean(detail_levels), 0.001))
+        
+        # 分析图像不同区域的细节一致性
+        block_size = 64
+        detail_blocks = []
+        
+        for i in range(0, gray.shape[0]-block_size, block_size):
+            for j in range(0, gray.shape[1]-block_size, block_size):
+                block = gray[i:i+block_size, j:j+block_size]
+                # 计算块的细节水平
+                block_laplacian = cv2.Laplacian(block, cv2.CV_64F)
+                detail_blocks.append(np.mean(np.abs(block_laplacian)))
+        
+        if detail_blocks:
+            # 计算细节分布的均匀性 - AI生成图像的细节分布通常不够均匀
+            features["detail_spatial_std"] = float(np.std(detail_blocks))
+            features["detail_spatial_entropy"] = float(stats.entropy(detail_blocks + 1e-10))
+        
+        # 边缘过渡分析
+        edges = cv2.Canny(gray, 50, 150)
+        dilated = cv2.dilate(edges, np.ones((3,3), np.uint8))
+        edge_transition = cv2.absdiff(dilated, edges)
+        
+        # 计算边缘过渡区域的特性 - 真实照片的边缘过渡更自然
+        if np.sum(edge_transition) > 0:
+            transition_values = gray[edge_transition > 0]
+            if len(transition_values) > 0:
+                features["edge_transition_std"] = float(np.std(transition_values))
+    except:
+        # 如果分析失败，不添加细节连贯性特征
+        pass
+    
+    return features
+
 def analyze_clothing_details(image):
     """分析衣物细节的自然度"""
     features = {}
@@ -316,7 +514,7 @@ def analyze_clothing_details(image):
                 features["clothing_angle_uniformity"] = float(max_count / max(total_count, 1))
         
         # 分析纹理的一致性
-        # 将图像分成小块，计算每个块的纹理特征
+ # 将图像分成小块，计算每个块的纹理特征
         block_size = 32
         h, w = gray.shape
         texture_variations = []
@@ -333,6 +531,30 @@ def analyze_clothing_details(image):
             
             # 计算纹理变化的均值 - AI生成的衣物纹理通常变化较小
             features["clothing_texture_mean"] = float(np.mean(texture_variations))
+            
+            # 计算纹理变化的熵 - 真实衣物纹理变化的熵更高
+            features["clothing_texture_entropy"] = float(stats.entropy(texture_variations + 1e-10))
+# 褶皱分析 - 使用形态学操作提取可能的褶皱
+        _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        kernel = np.ones((3,3), np.uint8)
+        opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
+        
+        # 寻找轮廓
+        contours, _ = cv2.findContours(opening, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # 分析轮廓的复杂度
+        if contours:
+            contour_complexities = []
+            for contour in contours:
+                area = cv2.contourArea(contour)
+                if area > 100:  # 忽略太小的轮廓
+                    perimeter = cv2.arcLength(contour, True)
+                    complexity = perimeter / max(np.sqrt(area), 1)
+                    contour_complexities.append(complexity)
+            
+            if contour_complexities:
+                features["clothing_contour_complexity"] = float(np.mean(contour_complexities))
+                features["clothing_contour_std"] = float(np.std(contour_complexities))
     except:
         # 如果分析失败，不添加衣物特征
         pass
@@ -390,6 +612,41 @@ def analyze_extremities(image):
                 if defect_depths:
                     features["extremity_defect_depth_mean"] = float(np.mean(defect_depths))
                     features["extremity_defect_depth_std"] = float(np.std(defect_depths))
+                    
+                    # 分析缺陷的分布 - 真实手指的缺陷分布更自然
+                    defect_hist, _ = np.histogram(defect_depths, bins=10)
+                    features["extremity_defect_entropy"] = float(stats.entropy(defect_hist + 1e-10))
+            
+            # 分析轮廓的曲率变化 - 真实手指的曲率变化更自然
+            curvature_variations = []
+            for contour in contours:
+                if len(contour) > 20:  # 需要足够多的点来计算曲率
+                    # 简化轮廓以减少噪声
+                    epsilon = 0.01 * cv2.arcLength(contour, True)
+                    approx = cv2.approxPolyDP(contour, epsilon, True)
+                    
+                    # 计算相邻点之间的角度变化
+                    angles = []
+                    for i in range(len(approx)):
+                        p1 = approx[i][0]
+                        p2 = approx[(i+1) % len(approx)][0]
+                        p3 = approx[(i+2) % len(approx)][0]
+                        
+                        # 计算两个向量之间的角度
+                        v1 = p2 - p1
+                        v2 = p3 - p2
+                        
+                        if np.linalg.norm(v1) > 0 and np.linalg.norm(v2) > 0:
+                            cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
+                            cos_angle = np.clip(cos_angle, -1.0, 1.0)  # 确保在有效范围内
+                            angle = np.arccos(cos_angle)
+                            angles.append(angle)
+                    
+                    if angles:
+                        curvature_variations.append(np.std(angles))
+            
+            if curvature_variations:
+                features["extremity_curvature_std"] = float(np.mean(curvature_variations))
     except:
         # 如果分析失败，不添加末端特征
         pass
@@ -405,7 +662,7 @@ def check_ai_specific_features(image_features):
     if "horizontal_symmetry" in image_features and "vertical_symmetry" in image_features:
         avg_symmetry = (image_features["horizontal_symmetry"] + image_features["vertical_symmetry"]) / 2
         if avg_symmetry > 0.8:  # 提高阈值
-            ai_score += 0.2  # 降低权重
+            ai_score += 0.15  # 降低权重
             ai_signs.append("图像对称性异常高")
         elif avg_symmetry > 0.7:
             ai_score += 0.1
@@ -414,7 +671,7 @@ def check_ai_specific_features(image_features):
     # 检查纹理相关性 - AI生成图像通常纹理相关性高
     if "texture_correlation" in image_features:
         if image_features["texture_correlation"] > 0.95:  # 提高阈值
-            ai_score += 0.2
+            ai_score += 0.15
             ai_signs.append("纹理相关性异常高")
         elif image_features["texture_correlation"] > 0.9:
             ai_score += 0.1
@@ -424,68 +681,147 @@ def check_ai_specific_features(image_features):
     if "edge_density" in image_features and "noise_level" in image_features:
         edge_noise_ratio = image_features["edge_density"] / max(image_features["noise_level"], 0.001)
         if edge_noise_ratio < 0.01:
-            ai_score += 0.2
+            ai_score += 0.15
             ai_signs.append("边缘与噪声分布不自然")
     
     # 检查颜色平滑度 - AI生成图像通常颜色过渡更平滑
     if "color_std" in image_features and image_features["color_std"] < 10:
-        ai_score += 0.1  # 降低权重
+        ai_score += 0.1
         ai_signs.append("颜色过渡异常平滑")
     
+    # 检查颜色熵 - AI生成图像通常颜色熵较低
+    if "color_entropy" in image_features and image_features["color_entropy"] < 5:
+        ai_score += 0.15
+        ai_signs.append("颜色分布熵值异常低")
+    
     # 检查纹理能量 - AI生成图像通常纹理能量分布不自然
     if "texture_energy" in image_features and image_features["texture_energy"] < 0.01:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("纹理能量分布不自然")
     
     # 检查频率比例 - AI生成图像通常频率分布不自然
     if "freq_ratio" in image_features:
         if image_features["freq_ratio"] < 0.1 or image_features["freq_ratio"] > 2.0:
-            ai_score += 0.1  # 降低权重
+            ai_score += 0.1
             ai_signs.append("频率分布不自然")
     
+    # 检查频率各向异性 - AI生成图像通常频率分布各向异性较低
+    if "freq_anisotropy" in image_features and image_features["freq_anisotropy"] < 0.5:
+        ai_score += 0.15
+        ai_signs.append("频率分布各向异性异常低")
+    
     # 检查局部颜色变化 - 真实照片通常有更多局部颜色变化
     if "local_color_variation" in image_features and image_features["local_color_variation"] < 5:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("局部颜色变化异常少")
     
     # 检查边缘变化 - 真实照片的边缘通常更自然
     if "edge_variance" in image_features and image_features["edge_variance"] < 100:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("边缘变化异常均匀")
     
+    # 检查边缘方向熵 - 真实照片的边缘方向熵通常更高
+    if "edge_direction_entropy" in image_features and image_features["edge_direction_entropy"] < 1.5:
+        ai_score += 0.15
+        ai_signs.append("边缘方向熵异常低")
+    
     # 检查噪声频谱 - 真实照片的噪声频谱更自然
     if "noise_spectrum_std" in image_features and image_features["noise_spectrum_std"] < 1000:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("噪��频谱异常规则")
     
+    # 检查噪声空间分布 - 真实照片的噪声空间分布更自然
+    if "noise_spatial_std" in image_features and image_features["noise_spatial_std"] < 0.5:
+        ai_score += 0.15
+        ai_signs.append("噪声空间分布异常均匀")
+    
+    # 检查细节尺度一致性 - AI生成图像的细节尺度一致性通常不够自然
+    if "detail_scale_consistency" in image_features and image_features["detail_scale_consistency"] < 0.2:
+        ai_score += 0.15
+        ai_signs.append("细节尺度变化异常均匀")
+    
+    # 检查细节空间分布 - AI生成图像的细节空间分布通常不够自然
+    if "detail_spatial_std" in image_features and image_features["detail_spatial_std"] < 5:
+        ai_score += 0.15
+        ai_signs.append("细节空间分布异常均匀")
+    
+    # 检查细节空间熵 - AI生成图像的细节空间熵通常较低
+    if "detail_spatial_entropy" in image_features and image_features["detail_spatial_entropy"] < 1.5:
+        ai_score += 0.15
+        ai_signs.append("细节空间熵异常低")
+    
+    # 检查边缘过渡 - AI生成图像的边缘过渡通常不够自然
+    if "edge_transition_std" in image_features and image_features["edge_transition_std"] < 10:
+        ai_score += 0.15
+        ai_signs.append("边缘过渡异常均匀")
+    
+    # 检查光影一致性 - AI生成图像的光影一致性通常过高
+    if "light_direction_consistency" in image_features and image_features["light_direction_consistency"] > 0.7:
+        ai_score += 0.15
+        ai_signs.append("光影方向一致性异常高")
+    
+    # 检查透视一致性 - AI生成图像的透视一致性通常过高
+    if "perspective_consistency" in image_features and image_features["perspective_consistency"] > 0.7:
+        ai_score += 0.15
+        ai_signs.append("透视一致性异常高")
+    
     # 检查人脸特征 - AI生成的人脸通常有特定特征
     if "face_symmetry" in image_features and image_features["face_symmetry"] > 0.8:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("人脸对称性异常高")
     
     if "face_skin_std" in image_features and image_features["face_skin_std"] < 10:
-        ai_score += 0.3
+        ai_score += 0.2
         ai_signs.append("皮肤质感异常均匀")
     
+    # 检查面部纹理变化 - AI生成的面部纹理变化通常不够自然
+    face_texture_keys = [k for k in image_features.keys() if k.startswith("face_") and k.endswith("_texture_variation")]
+    if face_texture_keys:
+        face_texture_variations = [image_features[k] for k in face_texture_keys]
+        if np.mean(face_texture_variations) < 5:
+            ai_score += 0.2
+            ai_signs.append("面部纹理变化异常均匀")
+    
     # 检查衣物特征 - AI生成的衣物通常有特定问题
     if "clothing_angle_uniformity" in image_features and image_features["clothing_angle_uniformity"] > 0.3:
-        ai_score += 0.3
+        ai_score += 0.2
         ai_signs.append("衣物褶皱角度分布不自然")
     
     if "clothing_texture_std" in image_features and image_features["clothing_texture_std"] < 100:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("衣物纹理变化异常均匀")
     
+    if "clothing_texture_entropy" in image_features and image_features["clothing_texture_entropy"] < 1.5:
+        ai_score += 0.15
+        ai_signs.append("衣物纹理熵异常低")
+    
+    if "clothing_contour_complexity" in image_features and image_features["clothing_contour_complexity"] < 5:
+        ai_score += 0.15
+        ai_signs.append("衣物轮廓复杂度异常低")
+    
     # 检查手部特征 - AI生成的手部通常有特定问题
     if "extremity_perimeter_area_ratio" in image_features:
         if image_features["extremity_perimeter_area_ratio"] < 0.05:
-            ai_score += 0.3
+            ai_score += 0.2
             ai_signs.append("手部/末端轮廓异常平滑")
     
     if "extremity_defect_depth_std" in image_features and image_features["extremity_defect_depth_std"] < 10:
-        ai_score += 0.2
+        ai_score += 0.15
         ai_signs.append("手指间隙异常均匀")
     
+    if "extremity_defect_entropy" in image_features and image_features["extremity_defect_entropy"] < 1.0:
+        ai_score += 0.15
+        ai_signs.append("手指间隙分布熵异常低")
+    
+    if "extremity_curvature_std" in image_features and image_features["extremity_curvature_std"] < 0.2:
+        ai_score += 0.15
+        ai_signs.append("手部曲率变化异常均匀")
+    
+    # 微观纹理分析 - AI生成图像的微观纹理通常不够自然
+    if "lbp_entropy" in image_features and image_features["lbp_entropy"] < 3.0:
+        ai_score += 0.2
+        ai_signs.append("微观纹理熵异常低")
+    
     return min(ai_score, 1.0), ai_signs
 
 def detect_beauty_filter_signs(image_features):
@@ -535,6 +871,19 @@ def detect_beauty_filter_signs(image_features):
             beauty_score += 0.1
             beauty_signs.append("面部对称性较高，可能使用了美颜")
     
+    # 检查面部纹理变化 - 美颜通常会使面部纹理更均匀
+    face_texture_keys = [k for k in image_features.keys() if k.startswith("face_") and k.endswith("_texture_variation")]
+    if face_texture_keys:
+        face_texture_variations = [image_features[k] for k in face_texture_keys]
+        if np.mean(face_texture_variations) < 10:
+            beauty_score += 0.2
+            beauty_signs.append("面部纹理变化异常均匀，典型美颜特征")
+    
+    # 检查边缘过渡 - 美颜通常会使边缘过渡更平滑
+    if "edge_transition_std" in image_features and image_features["edge_transition_std"] < 15:
+        beauty_score += 0.2
+        beauty_signs.append("边缘过渡异常平滑，典型美颜特征")
+    
     return min(beauty_score, 1.0), beauty_signs
 
 def detect_photoshop_signs(image_features):
@@ -550,7 +899,8 @@ def detect_photoshop_signs(image_features):
         elif image_features["texture_homogeneity"] > 0.3:
             ps_score += 0.1
             ps_signs.append("皮肤质感较为均匀")
-# 检查边缘不自然
+    
+    # 检查边缘不自然
     if "edge_density" in image_features:
         if image_features["edge_density"] < 0.01:
             ps_score += 0.2
@@ -587,6 +937,20 @@ def detect_photoshop_signs(image_features):
             ps_score += 0.2
             ps_signs.append("频率分布不自然，可能有过度锐化处理")
     
+    # 检查细节不一致
+    if "detail_spatial_std" in image_features and image_features["detail_spatial_std"] > 50:
+        ps_score += 0.2
+        ps_signs.append("图像细节分布不一致，可能有局部修饰")
+    
+    # 检查边缘过渡不自然
+    if "edge_transition_std" in image_features:
+        if image_features["edge_transition_std"] > 50:
+            ps_score += 0.2
+            ps_signs.append("边缘过渡不自然，可能有选区修饰")
+        elif image_features["edge_transition_std"] < 5:
+            ps_score += 0.2
+            ps_signs.append("边缘过渡过于平滑，可能有过度修饰")
+    
     return min(ps_score, 1.0), ps_signs
 
 def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_signs, beauty_signs, valid_models_count):
@@ -740,28 +1104,18 @@ def detect_ai_image(image):
     if "extremity_perimeter_area_ratio" in image_features and image_features["extremity_perimeter_area_ratio"] < 0.05:
         adjusted_probability = max(adjusted_probability, 0.7)
     
+    # 如果检测到微观纹理异常，提高AI概率
+    if "lbp_entropy" in image_features and image_features["lbp_entropy"] < 3.0:
+        adjusted_probability = max(adjusted_probability, 0.6)
+    
+    # 如果检测到频率分布异常，提高AI概率
+    if "freq_anisotropy" in image_features and image_features["freq_anisotropy"] < 0.5:
+        adjusted_probability = max(adjusted_probability, 0.6)
+    
     # 如果美颜分数高但AI特征分数不高，降低AI概率
     if beauty_score > 0.6 and ai_feature_score < 0.5:
         adjusted_probability = min(adjusted_probability, 0.5)
     
-    # 高对称性是AI生成的指标，但权重降低
-    if "horizontal_symmetry" in image_features and image_features["horizontal_symmetry"] > 0.8:
-        adjusted_probability += 0.1
-    if "vertical_symmetry" in image_features and image_features["vertical_symmetry"] > 0.8:
-        adjusted_probability += 0.1
-    
-    # 高纹理相关性通常表示AI生成
-    if "texture_correlation" in image_features and image_features["texture_correlation"] > 0.95:
-        adjusted_probability += 0.1
-    
-    # 低边缘密度通常表示AI生成
-    if image_features["edge_density"] < 0.01:
-        adjusted_probability += 0.1
-    
-    # 如果检测到人脸特征异常，增加AI概率
-    if "face_skin_std" in image_features and image_features["face_skin_std"] < 10:
-        adjusted_probability += 0.2
-    
     # 确保概率在0-1范围内
     adjusted_probability = min(1.0, max(0.0, adjusted_probability))
     
@@ -801,7 +1155,7 @@ iface = gr.Interface(
     inputs=gr.Image(type="pil"),
     outputs=gr.JSON(),
     title="增强型AI图像检测API",
-    description="多模型集成检测图像是否由AI生成，同时分析PS修图和美颜痕迹，特别关注衣物和手部等细节问题",
+    description="多模型集成检测图像是否由AI生成，同时分析PS修图和美颜痕迹，特别关注通用细节特征",
     examples=None,
     allow_flagging="never"
 )