app.py

import gradio as gr
import torch
from PIL import Image
import numpy as np
import cv2
from transformers import AutoImageProcessor, AutoModelForImageClassification

# 加载多个检测模型
models = {
    "model1": {
        "name": "umm-maybe/AI-image-detector",
        "processor": None,
        "model": None,
        "weight": 0.5
    },
    "model2": {
        "name": "microsoft/resnet-50",  # 通用图像分类模型
        "processor": None,
        "model": None,
        "weight": 0.25
    },
    "model3": {
        "name": "google/vit-base-patch16-224",  # Vision Transformer模型
        "processor": None,
        "model": None,
        "weight": 0.25
    }
}

# 初始化模型
for key in models:
    try:
        models[key]["processor"] = AutoImageProcessor.from_pretrained(models[key]["name"])
        models[key]["model"] = AutoModelForImageClassification.from_pretrained(models[key]["name"])
        print(f"成功加载模型: {models[key]['name']}")
    except Exception as e:
        print(f"加载模型 {models[key]['name']} 失败: {str(e)}")
        models[key]["processor"] = None
        models[key]["model"] = None

def process_model_output(model_info, outputs, probabilities):
    """处理不同模型的输出，统一返回AI生成概率"""
    model_name = model_info["name"].lower()
    
    # 针对不同模型的特殊处理
    if "ai-image-detector" in model_name:
        # umm-maybe/AI-image-detector模型特殊处理
        # 检查标签
        ai_label_idx = None
        human_label_idx = None
        
        for idx, label in model_info["model"].config.id2label.items():
            label_lower = label.lower()
            if "ai" in label_lower or "generated" in label_lower or "fake" in label_lower:
                ai_label_idx = idx
            if "human" in label_lower or "real" in label_lower:
                human_label_idx = idx
        
        # 修正后的标签解释逻辑
        if human_label_idx is not None:
            # 如果预测为human，则AI概率应该低
            ai_probability = 1 - float(probabilities[0][human_label_idx].item())
        elif ai_label_idx is not None:
            # 如果预测为AI，则AI概率应该高
            ai_probability = float(probabilities[0][ai_label_idx].item())
        else:
            # 默认情况
            ai_probability = 0.5
    
    elif "resnet" in model_name:
        # 通用图像分类模型，使用简单启发式方法
        predicted_class_idx = outputs.logits.argmax(-1).item()
        # 检查是否有与AI相关的类别
        predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower()
        
        # 简单启发式：检查类别名称是否包含与AI生成相关的关键词
        ai_keywords = ["artificial", "generated", "synthetic", "fake", "computer"]
        for keyword in ai_keywords:
            if keyword in predicted_class:
                return float(probabilities[0][predicted_class_idx].item())
        
        # 如果没有明确的AI类别，返回中等概率
        return 0.5
    
    elif "vit" in model_name:
        # Vision Transformer模型
        predicted_class_idx = outputs.logits.argmax(-1).item()
        # 同样检查类别名称
        predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower()
        
        # 简单启发式：检查类别名称是否包含与AI生成相关的关键词
        ai_keywords = ["artificial", "generated", "synthetic", "fake", "computer"]
        for keyword in ai_keywords:
            if keyword in predicted_class:
                return float(probabilities[0][predicted_class_idx].item())
        
        # 如果没有明确的AI类别，返回中等概率
        return 0.5
    
    # 默认处理
    predicted_class_idx = outputs.logits.argmax(-1).item()
    predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower()
    
    if "ai" in predicted_class or "generated" in predicted_class or "fake" in predicted_class:
        return float(probabilities[0][predicted_class_idx].item())
    else:
        return 1 - float(probabilities[0][predicted_class_idx].item())
    
    return ai_probability

def analyze_image_features(image):
    """分析图像特征"""
    # 转换为OpenCV格式
    img_array = np.array(image)
    if len(img_array.shape) == 3 and img_array.shape[2] == 3:
        img_cv = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
    else:
        img_cv = img_array
    
    features = {}
    
    # 基本特征
    features["width"] = image.width
    features["height"] = image.height
    features["aspect_ratio"] = image.width / max(1, image.height)
    
    # 颜色分析
    if len(img_array.shape) == 3:
        features["avg_red"] = float(np.mean(img_array[:,:,0]))
        features["avg_green"] = float(np.mean(img_array[:,:,1]))
        features["avg_blue"] = float(np.mean(img_array[:,:,2]))
        
        # 颜色标准差 - 用于检测颜色分布是否自然
        features["color_std"] = float(np.std([
            features["avg_red"], 
            features["avg_green"], 
            features["avg_blue"]
        ]))
        
        # 颜色局部变化 - 真实照片通常有更多局部颜色变化
        local_color_variations = []
        for i in range(0, img_array.shape[0]-10, 10):
            for j in range(0, img_array.shape[1]-10, 10):
                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))
    
    # 边缘一致性分析
    edges = cv2.Canny(img_cv, 100, 200)
    features["edge_density"] = float(np.sum(edges > 0) / (image.width * image.height))
    
    # 边缘自然度分析 - 真实照片的边缘通常更自然
    if len(img_array.shape) == 3:
        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
        sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
        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))
    
    # 纹理分析 - 使用灰度共生矩阵
    if len(img_array.shape) == 3:
        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
        from skimage.feature import graycomatrix, graycoprops
        
        # 计算GLCM
        distances = [5]
        angles = [0, np.pi/4, np.pi/2, 3*np.pi/4]
        glcm = graycomatrix(gray, distances=distances, angles=angles, symmetric=True, normed=True)
        
        # 计算GLCM属性
        features["texture_contrast"] = float(np.mean(graycoprops(glcm, 'contrast')[0]))
        features["texture_homogeneity"] = float(np.mean(graycoprops(glcm, 'homogeneity')[0]))
        features["texture_correlation"] = float(np.mean(graycoprops(glcm, 'correlation')[0]))
        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]))
    
    # 噪声分析
    if len(img_array.shape) == 3:
        blurred = cv2.GaussianBlur(img_cv, (5, 5), 0)
        noise = cv2.absdiff(img_cv, blurred)
        features["noise_level"] = float(np.mean(noise))
        
        # 噪声分布 - 用于检测噪声是否自然
        features["noise_std"] = float(np.std(noise))
        
        # 噪声频谱分析 - 真实照片的噪声频谱更自然
        noise_fft = np.fft.fft2(noise[:,:,0])
        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生成图像通常有更高的对称性
    if img_cv.shape[1] % 2 == 0:  # 确保宽度是偶数
        left_half = img_cv[:, :img_cv.shape[1]//2]
        right_half = cv2.flip(img_cv[:, img_cv.shape[1]//2:], 1)
        if left_half.shape == right_half.shape:
            h_symmetry = 1 - float(np.mean(cv2.absdiff(left_half, right_half)) / 255)
            features["horizontal_symmetry"] = h_symmetry
    
    if img_cv.shape[0] % 2 == 0:  # 确保高度是偶数
        top_half = img_cv[:img_cv.shape[0]//2, :]
        bottom_half = cv2.flip(img_cv[img_cv.shape[0]//2:, :], 0)
        if top_half.shape == bottom_half.shape:
            v_symmetry = 1 - float(np.mean(cv2.absdiff(top_half, bottom_half)) / 255)
            features["vertical_symmetry"] = v_symmetry
    
    # 频率域分析 - 检测不自然的频率分布
    if len(img_array.shape) == 3:
        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
        f_transform = np.fft.fft2(gray)
        f_shift = np.fft.fftshift(f_transform)
        magnitude = np.log(np.abs(f_shift) + 1)
        
        # 计算高频和低频成分的比例
        h, w = magnitude.shape
        center_h, center_w = h // 2, w // 2
        
        # 低频区域 (中心区域)
        low_freq_region = magnitude[center_h-h//8:center_h+h//8, center_w-w//8:center_w+w//8]
        low_freq_mean = np.mean(low_freq_region)
        
        # 高频区域 (边缘区域)
        high_freq_mean = np.mean(magnitude) - low_freq_mean
        
        features["freq_ratio"] = float(high_freq_mean / max(low_freq_mean, 0.001))
        
        # 频率分布的自然度 - 真实照片通常有更自然的频率分布
        freq_std = np.std(magnitude)
        features["freq_std"] = float(freq_std)
    
    # 尝试检测人脸
    try:
        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
        features["face_count"] = len(faces)
        
        if len(faces) > 0:
            # 分析人脸特征
            face_features = []
            for (x, y, w, h) in faces:
                face = img_cv[y:y+h, x:x+w]
                # 皮肤质感分析
                face_hsv = cv2.cvtColor(face, cv2.COLOR_BGR2HSV)
                skin_mask = cv2.inRange(face_hsv, (0, 20, 70), (20, 150, 255))
                skin_pixels = face[skin_mask > 0]
                if len(skin_pixels) > 0:
                    face_features.append({
                        "skin_std": float(np.std(skin_pixels)),
                        "skin_local_contrast": float(np.mean(cv2.Laplacian(face, cv2.CV_64F))),
                        "face_symmetry": analyze_face_symmetry(face)
                    })
            
            if face_features:
                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])
    except:
        # 如果人脸检测失败，不添加人脸特征
        pass
    
    # 分析衣物细节
    clothing_features = analyze_clothing_details(img_cv)
    features.update(clothing_features)
    
    # 分析手部和关节
    extremity_features = analyze_extremities(img_cv)
    features.update(extremity_features)
    
    return features

def analyze_face_symmetry(face):
    """分析人脸对称性"""
    if face.shape[1] % 2 == 0:  # 确保宽度是偶数
        left_half = face[:, :face.shape[1]//2]
        right_half = cv2.flip(face[:, face.shape[1]//2:], 1)
        if left_half.shape == right_half.shape:
            return 1 - float(np.mean(cv2.absdiff(left_half, right_half)) / 255)
    return 0.5  # 默认值

def analyze_clothing_details(image):
    """分析衣物细节的自然度"""
    features = {}
    
    try:
        # 转换为灰度图
        if len(image.shape) == 3:
            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        else:
            gray = image
            
        # 使用Canny边缘检测
        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:
            # 计算直线的角度分布
            angles = []
            for line in lines:
                x1, y1, x2, y2 = line[0]
                if x2 - x1 != 0:  # 避免除以零
                    angle = np.arctan((y2 - y1) / (x2 - x1)) * 180 / np.pi
                    angles.append(angle)
            
            if angles:
                # 计算角度的标准差 - AI生成的衣物褶皱通常角度分布不自然
                features["clothing_angle_std"] = float(np.std(angles))
                
                # 计算角度的直方图 - 检查是否有过多相似角度（AI生成特征）
                hist, _ = np.histogram(angles, bins=18, range=(-90, 90))
                max_count = np.max(hist)
                total_count = np.sum(hist)
                features["clothing_angle_uniformity"] = float(max_count / max(total_count, 1))
        
        # 分析纹理的一致性
        # 将图像分成小块，计算每个块的纹理特征
        block_size = 32
        h, w = gray.shape
        texture_variations = []
        
        for i in range(0, h-block_size, block_size):
            for j in range(0, w-block_size, block_size):
                block = gray[i:i+block_size, j:j+block_size]
                # 计算局部LBP特征或简单的方差
                texture_variations.append(np.var(block))
        
        if texture_variations:
            # 计算纹理变化的标准差 - 真实衣物纹理变化更自然
            features["clothing_texture_std"] = float(np.std(texture_variations))
            
            # 计算纹理变化的均值 - AI生成的衣物纹理通常变化较小
            features["clothing_texture_mean"] = float(np.mean(texture_variations))
    except:
        # 如果分析失败，不添加衣物特征
        pass
    
    return features

def analyze_extremities(image):
    """分析手指、脚趾等末端细节"""
    features = {}
    
    try:
        # 转换为灰度图
        if len(image.shape) == 3:
            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        else:
            gray = image
        
        # 使用形态学操作提取可能的手部区域
        _, thresh = cv2.threshold(gray, 120, 255, cv2.THRESH_BINARY)
        kernel = np.ones((5,5), np.uint8)
        opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
        
        # 寻找轮廓
        contours, _ = cv2.findContours(opening, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        # 分析轮廓的复杂度
        if contours:
            # 计算轮廓的周长与面积比 - 手指等细节会增加这个比值
            perimeter_area_ratios = []
            for contour in contours:
                area = cv2.contourArea(contour)
                if area > 100:  # 忽略太小的轮廓
                    perimeter = cv2.arcLength(contour, True)
                    ratio = perimeter / max(area, 1)
                    perimeter_area_ratios.append(ratio)
            
            if perimeter_area_ratios:
                features["extremity_perimeter_area_ratio"] = float(np.mean(perimeter_area_ratios))
                
                # 计算凸包缺陷 - 手指之间的间隙会产生凸包缺陷
                defect_depths = []
                for contour in contours:
                    if len(contour) > 5:  # 需要足够多的点来计算凸包
                        hull = cv2.convexHull(contour, returnPoints=False)
                        if len(hull) > 3:  # 需要至少4个点来计算凸包缺陷
                            try:
                                defects = cv2.convexityDefects(contour, hull)
                                if defects is not None:
                                    for i in range(defects.shape[0]):
                                        _, _, _, depth = defects[i, 0]
                                        defect_depths.append(depth)
                            except:
                                pass
                
                if defect_depths:
                    features["extremity_defect_depth_mean"] = float(np.mean(defect_depths))
                    features["extremity_defect_depth_std"] = float(np.std(defect_depths))
    except:
        # 如果分析失败，不添加末端特征
        pass
    
    return features

def check_ai_specific_features(image_features):
    """检查AI生成图像的典型特征"""
    ai_score = 0
    ai_signs = []
    
    # 检查对称性 - AI生成图像通常对称性高，但权重降低
    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_signs.append("图像对称性异常高")
        elif avg_symmetry > 0.7:
            ai_score += 0.1
            ai_signs.append("图像对称性较高")
    
    # 检查纹理相关性 - AI生成图像通常纹理相关性高
    if "texture_correlation" in image_features:
        if image_features["texture_correlation"] > 0.95:  # 提高阈值
            ai_score += 0.2
            ai_signs.append("纹理相关性异常高")
        elif image_features["texture_correlation"] > 0.9:
            ai_score += 0.1
            ai_signs.append("纹理相关性较高")
    
    # 检查边缘与噪声的关系 - AI生成图像通常边缘清晰但噪声不自然
    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_signs.append("边缘与噪声分布不自然")
    
    # 检查颜色平滑度 - AI生成图像通常颜色过渡更平滑
    if "color_std" in image_features and image_features["color_std"] < 10:
        ai_score += 0.1  # 降低权重
        ai_signs.append("颜色过渡异常平滑")
    
    # 检查纹理能量 - AI生成图像通常纹理能量分布不自然
    if "texture_energy" in image_features and image_features["texture_energy"] < 0.01:
        ai_score += 0.2
        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_signs.append("频率分布不自然")
    
    # 检查局部颜色变化 - 真实照片通常有更多局部颜色变化
    if "local_color_variation" in image_features and image_features["local_color_variation"] < 5:
        ai_score += 0.2
        ai_signs.append("局部颜色变化异常少")
    
    # 检查边缘变化 - 真实照片的边缘通常更自然
    if "edge_variance" in image_features and image_features["edge_variance"] < 100:
        ai_score += 0.2
        ai_signs.append("边缘变化异常均匀")
    
    # 检查噪声频谱 - 真实照片的噪声频谱更自然
    if "noise_spectrum_std" in image_features and image_features["noise_spectrum_std"] < 1000:
        ai_score += 0.2
        ai_signs.append("噪声频谱异常规则")
    
    # 检查人脸特征 - AI生成的人脸通常有特定特征
    if "face_symmetry" in image_features and image_features["face_symmetry"] > 0.8:
        ai_score += 0.2
        ai_signs.append("人脸对称性异常高")
    
    if "face_skin_std" in image_features and image_features["face_skin_std"] < 10:
        ai_score += 0.3
        ai_signs.append("皮肤质感异常均匀")
    
    # 检查衣物特征 - AI生成的衣物通常有特定问题
    if "clothing_angle_uniformity" in image_features and image_features["clothing_angle_uniformity"] > 0.3:
        ai_score += 0.3
        ai_signs.append("衣物褶皱角度分布不自然")
    
    if "clothing_texture_std" in image_features and image_features["clothing_texture_std"] < 100:
        ai_score += 0.2
        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_signs.append("手部/末端轮廓异常平滑")
    
    if "extremity_defect_depth_std" in image_features and image_features["extremity_defect_depth_std"] < 10:
        ai_score += 0.2
        ai_signs.append("手指间隙异常均匀")
    
    return min(ai_score, 1.0), ai_signs

def detect_beauty_filter_signs(image_features):
    """检测美颜滤镜痕迹"""
    beauty_score = 0
    beauty_signs = []
    
    # 检查皮肤质感
    if "face_skin_std" in image_features:
        if image_features["face_skin_std"] < 15:
            beauty_score += 0.3
            beauty_signs.append("皮肤质感过于均匀，典型美颜特征")
        elif image_features["face_skin_std"] < 25:
            beauty_score += 0.2
            beauty_signs.append("皮肤质感较为均匀，可能使用了美颜")
    
    # 检查局部对比度 - 美颜通常会降低局部对比度
    if "face_local_contrast" in image_features:
        if image_features["face_local_contrast"] < 5:
            beauty_score += 0.2
            beauty_signs.append("面部局部对比度低，典型美颜特征")
    
    # 检查边缘平滑度 - 美颜通常会平滑边缘
    if "edge_density" in image_features:
        if image_features["edge_density"] < 0.03:
            beauty_score += 0.2
            beauty_signs.append("边缘过于平滑，典型美颜特征")
        elif image_features["edge_density"] < 0.05:
            beauty_score += 0.1
            beauty_signs.append("边缘较为平滑，可能使用了美颜")
    
    # 检查噪点 - 美颜通常会减少噪点
    if "noise_level" in image_features:
        if image_features["noise_level"] < 1.0:
            beauty_score += 0.2
            beauty_signs.append("噪点异常少，典型美颜特征")
        elif image_features["noise_level"] < 2.0:
            beauty_score += 0.1
            beauty_signs.append("噪点较少，可能使用了美颜")
    
    # 检查人脸对称性 - 美颜通常会增加对称性
    if "face_symmetry" in image_features:
        if image_features["face_symmetry"] > 0.8:
            beauty_score += 0.2
            beauty_signs.append("面部对称性异常高，典型美颜特征")
        elif image_features["face_symmetry"] > 0.7:
            beauty_score += 0.1
            beauty_signs.append("面部对称性较高，可能使用了美颜")
    
    return min(beauty_score, 1.0), beauty_signs

def detect_photoshop_signs(image_features):
    """检测图像中的PS痕迹"""
    ps_score = 0
    ps_signs = []
    
    # 检查皮肤质感
    if "texture_homogeneity" in image_features:
        if image_features["texture_homogeneity"] > 0.4:
            ps_score += 0.2
            ps_signs.append("皮肤质感过于均匀")
        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
            ps_signs.append("边缘过于平滑")
        elif image_features["edge_density"] < 0.03:
            ps_score += 0.1
            ps_signs.append("边缘较为平滑")
    
    # 检查颜色不自然
    if "color_std" in image_features:
        if image_features["color_std"] > 50:
            ps_score += 0.2
            ps_signs.append("颜色分布极不自然")
        elif image_features["color_std"] > 30:
            ps_score += 0.1
            ps_signs.append("颜色分布略不自然")
    
    # 检查噪点不一致
    if "noise_level" in image_features and "noise_std" in image_features:
        noise_ratio = image_features["noise_std"] / max(image_features["noise_level"], 0.001)
        if noise_ratio < 0.5:
            ps_score += 0.2
            ps_signs.append("噪点分布不自然")
        elif noise_ratio < 0.7:
            ps_score += 0.1
            ps_signs.append("噪点分布略不自然")
    
    # 检查频率分布不自然
    if "freq_ratio" in image_features:
        if image_features["freq_ratio"] < 0.2:
            ps_score += 0.2
            ps_signs.append("频率分布不自然，可能有过度模糊处理")
        elif image_features["freq_ratio"] > 2.0:
            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):
    """提供更详细的分析结果"""
    
    # 根据有效模型数量调整置信度描述
    confidence_prefix = ""
    if valid_models_count >= 3:
        confidence_prefix = "极高置信度："
    elif valid_models_count == 2:
        confidence_prefix = "高置信度："
    elif valid_models_count == 1:
        confidence_prefix = "中等置信度："
    
    # 调整后的阈值判断，考虑美颜因素和衣物细节
    if ai_probability > 0.7:  # 高AI概率
        category = confidence_prefix + "高概率AI生成"
        description = "图像很可能是由AI完全生成，几乎没有真人照片的特征。"
    elif ai_probability > 0.5:  # 中等AI概率
        if beauty_score > 0.6:  # 高美颜分数
            category = confidence_prefix + "可能是重度美颜的真人照片"
            description = "图像可能是真人照片经过重度美颜处理，也可能是AI生成图像。"
        elif ps_score > 0.5:  # 高PS分数
            category = confidence_prefix + "中等概率AI生成，高概率PS修图"
            description = "图像可能是真人照片经过大量后期处理，或是AI生成后经过修饰的图像。"
        else:
            category = confidence_prefix + "中等概率AI生成"
            description = "图像有较多AI生成的特征，但也保留了一些真实照片的特点。"
    elif ai_probability > 0.3:  # 低AI概率
        if beauty_score > 0.5:  # 中高美颜分数
            category = confidence_prefix + "很可能是美颜处理的真人照片"
            description = "图像很可能是真人照片经过美颜处理，美颜痕迹明显。"
        elif ps_score > 0.5:  # 高PS分数
            category = confidence_prefix + "低概率AI生成，高概率PS修图"
            description = "图像更可能是真人照片经过大量后期处理，PS痕迹明显。"
        else:
            category = confidence_prefix + "低概率AI生成"
            description = "图像更可能是真人照片，但有一些AI生成或修饰的特征。"
    else:  # 很低AI概率
        if beauty_score > 0.6:
            category = confidence_prefix + "真人照片，重度美颜处理"
            description = "图像基本是真人照片，但经过了重度美颜处理。"
        elif ps_score > 0.6:
            category = confidence_prefix + "真人照片，重度PS修图"
            description = "图像基本是真人照片，但经过了大量后期处理，修饰痕迹明显。"
        elif ps_score > 0.3 or beauty_score > 0.3:
            category = confidence_prefix + "真人照片，中度修图或美颜"
            description = "图像是真人照片，有明显的后期处理或美颜痕迹。"
        elif ps_score > 0.1 or beauty_score > 0.1:
            category = confidence_prefix + "真人照片，轻度修图或美颜"
            description = "图像是真人照片，有少量后期处理或美颜。"
        else:
            category = confidence_prefix + "高概率真人照片，几乎无修图"
            description = "图像几乎可以确定是未经大量处理的真人照片。"
    
    # 添加具体的PS痕迹描述
    if ps_signs:
        ps_details = "检测到的修图痕迹：" + "、".join(ps_signs)
    else:
        ps_details = "未检测到明显的修图痕迹。"
    
    # 添加AI特征描述
    if ai_signs:
        ai_details = "检测到的AI特征：" + "、".join(ai_signs)
    else:
        ai_details = "未检测到明显的AI生成特征。"
    
    # 添加美颜特征描述
    if beauty_signs:
        beauty_details = "检测到的美颜特征：" + "、".join(beauty_signs)
    else:
        beauty_details = "未检测到明显的美颜特征。"
    
    return category, description, ps_details, ai_details, beauty_details

def detect_ai_image(image):
    """主检测函数"""
    if image is None:
        return {"error": "未提供图像"}
    
    results = {}
    valid_models = 0
    weighted_ai_probability = 0
    
    # 使用每个模型进行预测
    for key, model_info in models.items():
        if model_info["processor"] is not None and model_info["model"] is not None:
            try:
                # 处理图像
                inputs = model_info["processor"](images=image, return_tensors="pt")
                with torch.no_grad():
                    outputs = model_info["model"](**inputs)
                
                # 获取概率
                probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
                
                # 使用适配器处理不同模型的输出
                ai_probability = process_model_output(model_info, outputs, probabilities)
                
                # 添加到结果
                predicted_class_idx = outputs.logits.argmax(-1).item()
                results[key] = {
                    "model_name": model_info["name"],
                    "ai_probability": ai_probability,
                    "predicted_class": model_info["model"].config.id2label[predicted_class_idx]
                }
                
                # 累加加权概率
                weighted_ai_probability += ai_probability * model_info["weight"]
                valid_models += 1
            
            except Exception as e:
                results[key] = {
                    "model_name": model_info["name"],
                    "error": str(e)
                }
    
    # 计算最终加权概率
    if valid_models > 0:
        final_ai_probability = weighted_ai_probability / sum(m["weight"] for k, m in models.items() if m["processor"] is not None and m["model"] is not None)
    else:
        return {"error": "所有模型加载失败"}
    
    # 分析图像特征
    image_features = analyze_image_features(image)
    
    # 检查AI特定特征
    ai_feature_score, ai_signs = check_ai_specific_features(image_features)
    
    # 分析PS痕迹
    ps_score, ps_signs = detect_photoshop_signs(image_features)
    
    # 分析美颜痕迹
    beauty_score, beauty_signs = detect_beauty_filter_signs(image_features)
    
    # 应用特征权重调整AI概率
    adjusted_probability = final_ai_probability
    
    # 如果AI特征分数高，提高AI概率
    if ai_feature_score > 0.7:
        adjusted_probability = max(adjusted_probability, 0.7)
    elif ai_feature_score > 0.5:
        adjusted_probability = max(adjusted_probability, 0.6)
    elif ai_feature_score > 0.3:
        adjusted_probability = max(adjusted_probability, 0.5)
    
    # 如果检测到衣物或手部异常，大幅提高AI概率
    if "clothing_angle_uniformity" in image_features and image_features["clothing_angle_uniformity"] > 0.3:
        adjusted_probability = max(adjusted_probability, 0.7)
    
    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特征分数不高，降低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))
    
    # 如果umm-maybe/AI-image-detector模型的预测与其他模型不一致，增加其权重
    if "model1" in results and "ai_probability" in results["model1"]:
        ai_detector_prob = results["model1"]["ai_probability"]
        # 如果专用AI检测器给出的概率与调整后概率差异大，增加其权重
        if abs(ai_detector_prob - adjusted_probability) > 0.3:
            adjusted_probability = (adjusted_probability + ai_detector_prob * 2) / 3
    
    # 获取详细分析
    category, description, ps_details, ai_details, beauty_details = get_detailed_analysis(
        adjusted_probability, ps_score, beauty_score, ps_signs, ai_signs, beauty_signs, valid_models
    )
    
    # 构建最终结果
    final_result = {
        "ai_probability": adjusted_probability,
        "original_ai_probability": final_ai_probability,
        "ps_score": ps_score,
        "beauty_score": beauty_score,
        "ai_feature_score": ai_feature_score,
        "category": category,
        "description": description,
        "ps_details": ps_details,
        "ai_details": ai_details,
        "beauty_details": beauty_details,
        "individual_model_results": results,
        "features": image_features
    }
    
    return final_result

# 创建Gradio界面
iface = gr.Interface(
    fn=detect_ai_image,
    inputs=gr.Image(type="pil"),
    outputs=gr.JSON(),
    title="增强型AI图像检测API",
    description="多模型集成检测图像是否由AI生成，同时分析PS修图和美颜痕迹，特别关注衣物和手部等细节问题",
    examples=None,
    allow_flagging="never"
)

iface.launch()