1
class DepressionInference:
2
    """抑郁检测推理引擎"""
3

4
    def __init__(self):
5
        """初始化推理引擎"""
6
        self.models = {}          # 分类模型字典
7
        self.score_models = {}    # 回归模型字典（用于严重程度评估）
8
        self.schema = {}          # 特征列架构
9
        self.thresholds = {}      # 判定阈值
10
        self.load_resources()     # 加载所有资源
11

12
    def load_resources(self):
13
        """加载模型、特征架构和阈值配置"""
14
        # 1. 加载特征架构
15
        # 2. 加载阈值配置
16
        # 3. 加载分类和回归模型

1
def load_models(self):
2
    """加载所有模型文件"""
3
    model_dir = config_local.MODEL_DIR
4

5
    # 分类模型路径配置
6
    classification_models = {
7
        'audio': "depression_audio_model.pkl",
8
        'visual': "depression_visual_model.pkl",
9
        'multimodal': "depression_high_quality_model.pkl"
10
    }
11

12
    # 回归模型路径配置（用于严重程度评估）
13
    regression_models = {
14
        'audio': "depression_audio_score_model.pkl",
15
        'visual': "depression_visual_score_model.pkl",
16
        'multimodal': "depression_score_model.pkl"
17
    }
18

19
    # 加载分类模型
20
    for model_type, filename in classification_models.items():
21
        model_path = os.path.join(model_dir, filename)
22
        if os.path.exists(model_path):
23
            self.models[model_type] = joblib.load(model_path)
24

25
    # 加载回归模型
26
    for model_type, filename in regression_models.items():
27
        model_path = os.path.join(model_dir, filename)
28
        if os.path.exists(model_path):
29
            self.score_models[model_type] = joblib.load(model_path)

1
def prepare_features(self, combined_features, mode):
2
    """
3
    准备模型输入特征
4

5
    参数:
6
        combined_features: 包含所有特征的字典
7
        mode: 模型类型 ('audio', 'visual', 'multimodal')
8

9
    返回:
10
        numpy数组: 模型输入特征向量
11
    """
12
    # 根据模型类型获取特征列
13
    if mode == 'multimodal':
14
        feature_cols = self.schema.get('multimodal_feature_cols', [])
15
        if not feature_cols:
16
            # 回退策略：拼接音频和视频特征
17
            audio_cols = [k for k in combined_features.keys() if k.startswith('aud_')]
18
            visual_cols = [k for k in combined_features.keys() if k.startswith('vis_')]
19
            feature_cols = audio_cols + visual_cols
20
    else:
21
        feature_cols_key = f"{mode}_feature_cols"
22
        feature_cols = self.schema.get(feature_cols_key, [])
23
        if not feature_cols:
24
            # 回退策略：根据前缀筛选特征
25
            prefix = 'aud_' if mode == 'audio' else 'vis_'
26
            feature_cols = [k for k in combined_features.keys() if k.startswith(prefix)]
27

28
    # 构建特征向量
29
    feature_vector = []
30
    for col in feature_cols:
31
        feature_value = combined_features.get(col, 0.0)
32
        feature_vector.append(float(feature_value))
33

34
    return np.array(feature_vector).reshape(1, -1)

1
def detect_modality(self, combined_features):
2
    """
3
    检测可用的模态类型
4

5
    参数:
6
        combined_features: 提取的特征字典
7

8
    返回:
9
        str: 最佳模型类型 ('multimodal', 'audio', 'visual', 'none')
10
    """
11
    # 检查特征前缀判断模态
12
    has_audio = any(k.startswith('aud_') for k in combined_features)
13
    has_visual = any(k.startswith('vis_') for k in combined_features)
14

15
    # 音频有效性验证
16
    if has_audio:
17
        f0_mean = combined_features.get('aud_f0_mean', 0)
18
        # 基频过低可能表示无效音频
19
        if f0_mean < 40:
20
            has_audio = False
21

22
    # 模型可用性检查
23
    has_audio_model = 'audio' in self.models
24
    has_visual_model = 'visual' in self.models
25
    has_multimodal_model = 'multimodal' in self.models
26

27
    # 自动模型选择逻辑
28
    if has_audio and has_visual:
29
        # 多模态输入，优先使用融合策略
30
        return 'multimodal_fusion'
31
    elif has_audio and has_audio_model:
32
        # 仅音频输入
33
        return 'audio'
34
    elif has_visual and has_visual_model:
35
        # 仅视频输入
36
        return 'visual'
37
    else:
38
        # 无可用模型或特征不足
39
        return 'none'

1
def predict(self, combined_features):
2
    """
3
    核心推理逻辑，支持自动模型切换
4

5
    参数:
6
        combined_features: 提取的特征字典
7

8
    返回:
9
        dict: 包含预测结果的字典
10
    """
11
    # 1. 检测模态类型
12
    mode = self.detect_modality(combined_features)
13

14
    if mode == 'none':
15
        return {
16
            'error': '无可用模型或特征不足',
17
            'proba': 0,
18
            'threshold': 0,
19
            'severity': '无法评估'
20
        }
21

22
    # 2. 根据模态类型执行推理
23
    if mode == 'multimodal_fusion':
24
        # 多模态融合推理
25
        result = self._predict_multimodal_fusion(combined_features)
26
    else:
27
        # 单模态推理
28
        result = self._predict_single_modality(combined_features, mode)
29

30
    return result

1
def _predict_multimodal_fusion(self, combined_features):
2
    """
3
    多模态决策融合推理
4

5
    参数:
6
        combined_features: 包含音频和视频特征的字典
7

8
    返回:
9
        dict: 融合后的预测结果
10
    """
11
    # 音频模型推理
12
    audio_features = self.prepare_features(combined_features, 'audio')
13
    audio_proba = float(self.models['audio'].predict_proba(audio_features)[0][1])
14

15
    # 视频模型推理
16
    visual_features = self.prepare_features(combined_features, 'visual')
17
    visual_proba = float(self.models['visual'].predict_proba(visual_features)[0][1])
18

19
    # 加权融合（基于实验确定的最佳权重）
20
    # 音频权重：0.55，视频权重：0.45
21
    fused_proba = audio_proba * 0.55 + visual_proba * 0.45
22

23
    # 获取多模态阈值
24
    threshold, threshold_source = self.get_threshold('multimodal')
25

26
    # 判定结果
27
    is_depressed = fused_proba >= threshold
28

29
    # 构建融合特征用于严重程度评估
30
    if 'multimodal_feature_cols' in self.schema:
31
        fusion_features = self.prepare_features(combined_features, 'multimodal')
32
    else:
33
        # 特征拼接：音频特征在前，视频特征在后
34
        fusion_features = np.hstack((audio_features, visual_features))
35

36
    # 严重程度评估
37
    severity_result = self._evaluate_severity(fusion_features, 'multimodal')
38

39
    return {
40
        'mode': 'multimodal',
41
        'proba': fused_proba,
42
        'threshold': threshold,
43
        'threshold_source': threshold_source,
44
        'is_depressed': is_depressed,
45
        **severity_result
46
    }

1
def analyze_feature_contribution(self, features, model_type):
2
    """
3
    分析特征对预测结果的贡献度
4

5
    参数:
6
        features: 输入特征向量
7
        model_type: 模型类型
8

9
    返回:
10
        list: 特征贡献度列表
11
    """
12
    if model_type not in self.models:
13
        return []
14

15
    model = self.models[model_type]
16

17
    # 获取模型系数（仅适用于线性模型）
18
    if hasattr(model, 'coef_'):
19
        coefficients = model.coef_[0]
20

21
        # 获取特征列名
22
        if model_type == 'multimodal':
23
            feature_names = self.schema.get('multimodal_feature_cols', [])
24
        else:
25
            feature_names = self.schema.get(f'{model_type}_feature_cols', [])
26

27
        # 计算每个特征的贡献度
28
        contributions = []
29
        for i, (feature_name, coef, feature_value) in enumerate(zip(
30
            feature_names, coefficients, features[0]
31
        )):
32
            contribution = coef * feature_value
33
            contributions.append({
34
                'feature': feature_name,
35
                'value': feature_value,
36
                'coefficient': coef,
37
                'contribution': contribution
38
            })
39

40
        # 按贡献度绝对值排序
41
        contributions.sort(key=lambda x: abs(x['contribution']), reverse=True)
42
        return contributions
43

44
    return []

1
def identify_risk_factors(self, features, contributions):
2
    """
3
    识别关键风险因素
4

5
    参数:
6
        features: 输入特征
7
        contributions: 特征贡献度列表
8

9
    返回:
10
        dict: 风险因素分析结果
11
    """
12
    risk_factors = {
13
        'audio_risk_factors': [],
14
        'visual_risk_factors': [],
15
        'summary': ''
16
    }
17

18
    # 音频风险因素
19
    audio_contributions = [c for c in contributions if c['feature'].startswith('aud_')]
20

21
    # 检查语音特征风险
22
    if 'aud_f0_mean' in features:
23
        f0_mean = features['aud_f0_mean']
24
        if f0_mean < 100:  # 基频过低
25
            risk_factors['audio_risk_factors'].append('语音基频过低，可能表现为情绪低落')
26

27
    if 'aud_voiced_ratio' in features:
28
        voiced_ratio = features['aud_voiced_ratio']
29
        if voiced_ratio < 0.6:  # 语音比例过低
30
            risk_factors['audio_risk_factors'].append('语音比例低，可能存在言语减少')
31

32
    # 视频风险因素
33
    visual_contributions = [c for c in contributions if c['feature'].startswith('vis_')]
34

35
    # 检查面部表情特征
36
    if 'vis_AU12_r_mean' in features:  # 微笑强度
37
        smile_intensity = features['vis_AU12_r_mean']
38
        if smile_intensity < 0.5:
39
            risk_factors['visual_risk_factors'].append('微笑表情少，可能情绪低落')
40

41
    if 'vis_AU04_r_mean' in features:  # 眉毛降低（悲伤）
42
        brow_lower = features['vis_AU04_r_mean']
43
        if brow_lower > 2.0:
44
            risk_factors['visual_risk_factors'].append('频繁皱眉，可能存在悲伤情绪')
45

46
    # 生成总结
47
    all_factors = risk_factors['audio_risk_factors'] + risk_factors['visual_risk_factors']
48
    if all_factors:
49
        risk_factors['summary'] = '、'.join(all_factors)
50
    else:
51
        risk_factors['summary'] = '未发现明显风险因素'
52

53
    return risk_factors

1
def generate_visualization(self, result):
2
    """
3
    生成结果可视化数据
4

5
    参数:
6
        result: 推理结果字典
7

8
    返回:
9
        dict: 可视化数据
10
    """
11
    visualization = {
12
        'gauge_data': {
13
            'value': result['proba'] * 100,
14
            'threshold': result['threshold'] * 100,
15
            'severity': result['severity'],
16
            'severity_color': result['severity_color']
17
        },
18
        'risk_factors': {
19
            'audio': [],
20
            'visual': []
21
        },
22
        'feature_importance': []
23
    }
24

25
    # 风险因素可视化
26
    if 'risk_factors' in result:
27
        visualization['risk_factors'] = result['risk_factors']
28

29
    # 特征重要性可视化
30
    if 'feature_contributions' in result:
31
        top_features = result['feature_contributions'][:5]  # 取前5个最重要特征
32
        visualization['feature_importance'] = [
33
            {
34
                'name': feat['feature'].replace('aud_', '音频_').replace('vis_', '视频_'),
35
                'contribution': feat['contribution'],
36
                'value': feat['value']
37
            }
38
            for feat in top_features
39
        ]
40

41
    return visualization

1
def predict_safe(self, features):
2
    """
3
    安全的预测方法，包含完整的异常处理
4

5
    参数:
6
        features: 输入特征字典
7

8
    返回:
9
        dict: 预测结果或错误信息
10
    """
11
    try:
12
        # 验证输入特征
13
        if not isinstance(features, dict) or not features:
14
            return {
15
                'error': '输入特征无效',
16
                'proba': 0,
17
                'severity': '无法评估'
18
            }
19

20
        # 执行预测
21
        result = self.predict(features)
22

23
        # 验证输出结果
24
        if not isinstance(result, dict) or 'error' in result:
25
            return {
26
                'error': result.get('error', '预测失败'),
27
                'proba': 0,
28
                'severity': '无法评估'
29
            }
30

31
        return result
32

33
    except KeyError as e:
34
        return {
35
            'error': f'特征缺失: {e}',
36
            'proba': 0,
37
            'severity': '无法评估'
38
        }
39
    except ValueError as e:
40
        return {
41
            'error': f'特征值错误: {e}',
42
            'proba': 0,
43
            'severity': '无法评估'
44
        }
45
    except Exception as e:
46
        return {
47
            'error': f'预测过程出错: {str(e)}',
48
            'proba': 0,
49
            'severity': '无法评估'
50
        }

1
def format_error_message(self, error_type, details=None):
2
    """
3
    格式化错误信息
4

5
    参数:
6
        error_type: 错误类型
7
        details: 错误详情
8

9
    返回:
10
        str: 格式化的错误信息
11
    """
12
    error_templates = {
13
        'feature_missing': '缺少必要的特征数据',
14
        'model_not_found': '模型文件未找到，请检查模型路径',
15
        'invalid_input': '输入数据无效，请检查文件格式',
16
        'processing_error': '数据处理失败',
17
        'prediction_error': '预测过程出错',
18
        'unknown_error': '发生未知错误'
19
    }
20

21
    message = error_templates.get(error_type, error_templates['unknown_error'])
22

23
    if details:
24
        message += f"：{details}"
25

26
    return message

1
def ensure_system_stability(self):
2
    """
3
    确保系统稳定性的检查和修复
4

5
    返回:
6
        bool: 系统是否稳定
7
    """
8
    issues = []
9

10
    # 1. 检查模型文件
11
    for model_type, model in self.models.items():
12
        if model is None:
13
            issues.append(f"{model_type}模型未加载")
14

15
    # 2. 检查特征架构
16
    if not self.schema:
17
        issues.append("特征架构未加载")
18

19
    # 3. 检查阈值配置
20
    if not self.thresholds:
21
        issues.append("阈值配置未加载")
22

23
    # 4. 检查输出目录
24
    output_dir = config_local.REPORT_SAVE_DIR
25
    if not os.path.exists(output_dir):
26
        try:
27
            os.makedirs(output_dir)
28
        except Exception as e:
29
            issues.append(f"无法创建输出目录: {e}")
30

31
    # 5. 检查外部依赖
32
    if not self._check_external_dependencies():
33
        issues.append("外部依赖检查失败")
34

35
    return len(issues) == 0

1
import tkinter as tk
2
from tkinter import ttk
3

4
# 创建主窗口
5
root = tk.Tk()
6
root.title("多模态抑郁风险评估系统")
7
root.geometry("900x700")
8

9
# 设置窗口图标
10
try:
11
    root.iconbitmap("favicon.ico")
12
except Exception as e:
13
    print(f"图标加载失败: {e}")
14

15
# 运行主循环
16
root.mainloop()

1
class DepressionTestApp:
2
    def __init__(self, root):
3
        self.root = root
4
        self.root.title("多模态抑郁风险评估系统")
5
        self.root.geometry("900x700")
6

7
        # 初始化推理引擎
8
        self.predictor = inference.DepressionInference()
9

10
        # 任务控制
11
        self.cancel_event = threading.Event()
12

13
        # 样式配置
14
        self.setup_styles()
15

16
        # 构建界面
17
        self.create_widgets()

1
def create_widgets(self):
2
    # 主容器 - 使用pack布局
3
    main_frame = ttk.Frame(self.root, style="Main.TFrame", padding="20")
4
    main_frame.pack(fill=tk.BOTH, expand=True)
5

6
    # 标题 - 使用pack布局
7
    ttk.Label(main_frame, text="🧠 多模态抑郁风险评估系统", style="Title.TLabel").pack(pady=(0, 20))
8

9
    # 用户信息区域 - 使用grid布局
10
    user_frame = ttk.LabelFrame(main_frame, text="个人信息", padding="15")
11
    user_frame.pack(fill=tk.X, pady=10)
12

13
    grid_opts = {'padx': 10, 'pady': 5, 'sticky': 'w'}
14
    ttk.Label(user_frame, text="姓名:").grid(row=0, column=0, **grid_opts)
15
    self.name_var = tk.StringVar()
16
    ttk.Entry(user_frame, textvariable=self.name_var, width=20).grid(row=0, column=1, **grid_opts)
17

18
    # 文件选择区域 - 使用pack布局
19
    file_frame = ttk.LabelFrame(main_frame, text="数据输入", padding="15")
20
    file_frame.pack(fill=tk.X, pady=10)
21

22
    self.file_path_var = tk.StringVar()
23
    ttk.Entry(file_frame, textvariable=self.file_path_var, width=60).pack(side=tk.LEFT, padx=(0, 10), fill=tk.X, expand=True)
24
    ttk.Button(file_frame, text="📂 选择音视频文件", command=self.browse_file).pack(side=tk.LEFT)

1
def setup_styles(self):
2
    """配置界面样式"""
3
    style = ttk.Style()
4

5
    # 使用Windows原生风格
6
    try:
7
        style.theme_use('vista')
8
    except:
9
        style.theme_use('alt')
10

11
    # 定义颜色方案
12
    COLORS = {
13
        'bg': "#f5f6fa",             # 浅灰白背景
14
        'text': "#2c3e50",           # 深色文本
15
        'accent': "#3498db",         # 蓝色强调
16
        'card_bg': "white"           # 白色卡片
17
    }
18

19
    # 配置组件样式
20
    style.configure("Title.TLabel",
21
                   font=("Microsoft YaHei", 24, "bold"),
22
                   background=COLORS['bg'],
23
                   foreground=COLORS['text'])
24

25
    style.configure("Header.TLabel",
26
                   font=("Microsoft YaHei", 14, "bold"),
27
                   background=COLORS['bg'],
28
                   foreground=COLORS['accent'])
29

30
    style.configure("Card.TFrame",
31
                   background="white",
32
                   relief="solid",
33
                   borderwidth=1)

1
# 用户信息区域
2
user_frame = ttk.LabelFrame(main_frame, text="个人信息", padding="15")
3
user_frame.pack(fill=tk.X, pady=10)
4

5
grid_opts = {'padx': 10, 'pady': 5, 'sticky': 'w'}
6

7
# 姓名字段
8
ttk.Label(user_frame, text="姓名:").grid(row=0, column=0, **grid_opts)
9
self.name_var = tk.StringVar()
10
ttk.Entry(user_frame, textvariable=self.name_var, width=20).grid(row=0, column=1, **grid_opts)
11

12
# 性别字段
13
ttk.Label(user_frame, text="性别:").grid(row=0, column=2, **grid_opts)
14
self.gender_var = tk.StringVar(value="男")
15
ttk.Combobox(user_frame,
16
             textvariable=self.gender_var,
17
             values=["男", "女"],
18
             width=10,
19
             state="readonly").grid(row=0, column=3, **grid_opts)
20

21
# 年龄字段
22
ttk.Label(user_frame, text="年龄:").grid(row=0, column=4, **grid_opts)
23
self.age_var = tk.StringVar()
24
ttk.Entry(user_frame, textvariable=self.age_var, width=10).grid(row=0, column=5, **grid_opts)

1
# 文件选择区域
2
file_frame = ttk.LabelFrame(main_frame, text="数据输入", padding="15")
3
file_frame.pack(fill=tk.X, pady=10)
4

5
self.file_path_var = tk.StringVar()
6
ttk.Entry(file_frame, textvariable=self.file_path_var, width=60).pack(side=tk.LEFT, padx=(0, 10), fill=tk.X, expand=True)
7
ttk.Button(file_frame, text="📂 选择音视频文件", command=self.browse_file, style="Action.TButton").pack(side=tk.LEFT)
8

9
def browse_file(self):
10
    """浏览并选择音视频文件"""
11
    file_path = filedialog.askopenfilename(
12
        filetypes=[
13
            ("Media Files", "*.mp4 *.avi *.wav *.mp3 *.mkv"),
14
            ("All Files", "*.*")
15
        ]
16
    )
17
    if file_path:
18
        self.file_path_var.set(file_path)

1
def start_analysis(self):
2
    """开始分析任务"""
3
    file_path = self.file_path_var.get()
4
    if not file_path or not os.path.exists(file_path):
5
        messagebox.showerror("错误", "请选择有效的文件路径")
6
        return
7

8
    # 更新UI状态
9
    self.btn_action.config(text="⏹️ 停止评估", style="Danger.TButton")
10
    self.progress['value'] = 0
11
    self.cancel_event.clear()
12

13
    # 清空日志
14
    self.log_text.config(state="normal")
15
    self.log_text.delete('1.0', tk.END)
16
    self.log_text.config(state="disabled")
17

18
    self.log("正在启动分析任务...")
19

20
    # 在新线程中执行任务
21
    threading.Thread(target=self.run_task, args=(file_path,), daemon=True).start()
22

23
def run_task(self, file_path):
24
    """在后台线程中执行分析任务"""
25
    try:
26
        # 进度更新回调
27
        def update_progress(val):
28
            self.root.after(0, lambda: self.progress.configure(value=val))
29

30
        update_progress(5)
31

32
        # 1. 特征提取
33
        is_video = file_path.lower().endswith(('.mp4', '.avi', '.mov', '.mkv'))
34

35
        visual_features = {}
36
        if is_video:
37
            visual_features = feature_extractor.extract_visual_features(
38
                file_path, self.log, update_progress, self.cancel_event
39
            )
40
        else:
41
            self.log("⚠️ 输入为音频文件，跳过视觉提取")
42
            update_progress(40)
43

44
        # 检查取消标志
45
        if self.cancel_event.is_set():
46
            self.log("⚠️ 任务已取消")
47
            return
48

49
        # 提取音频特征
50
        audio_features = feature_extractor.extract_audio_features(
51
            file_path, self.log, update_progress, self.cancel_event
52
        )
53

54
        # 检查取消标志
55
        if self.cancel_event.is_set():
56
            self.log("⚠️ 任务已取消")
57
            return
58

59
        # 合并特征
60
        combined_features = {**visual_features, **audio_features}
61

62
        # 2. 推理
63
        self.log("🧠 正在进行模型推理...")
64
        update_progress(95)
65
        result = self.predictor.predict(combined_features)
66

67
        # 3. 结果处理和报告生成
68
        # ...
69

70
    except Exception as e:
71
        self.log(f"❌ 发生未预期的错误: {e}")
72
        import traceback
73
        print(traceback.format_exc())
74
    finally:
75
        # 在主线程中重置UI状态
76
        self.root.after(0, lambda: self.reset_ui_state())

1
def log(self, msg, level="info"):
2
    """
3
    带颜色和时间戳的日志输出
4

5
    参数:
6
        msg: 日志消息
7
        level: 日志级别 (info, success, warning, error, highlight)
8
    """
9
    # 自动推断日志级别
10
    if "⚠️" in msg: level = "warning"
11
    elif "❌" in msg or "🛑" in msg: level = "error"
12
    elif "✅" in msg: level = "success"
13
    elif "🧠" in msg or "🚀" in msg: level = "highlight"
14

15
    def _log():
16
        self.log_text.config(state="normal")
17
        timestamp = datetime.datetime.now().strftime('%H:%M:%S')
18

19
        # 插入时间戳
20
        self.log_text.insert(tk.END, f"[{timestamp}] ", "timestamp")
21
        # 插入消息
22
        self.log_text.insert(tk.END, f"{msg}\n", level)
23

24
        self.log_text.see(tk.END)
25
        self.log_text.config(state="disabled")
26

27
    # 在主线程中更新UI
28
    self.root.after(0, _log)

1
def toggle_analysis(self):
2
    """开始/停止分析的切换逻辑"""
3
    if self.btn_action['text'] == "🚀 开始评估":
4
        self.start_analysis()
5
    else:
6
        self.stop_analysis()
7

8
def stop_analysis(self):
9
    """停止当前分析任务"""
10
    if messagebox.askyesno("确认", "确定要停止当前任务吗？"):
11
        self.cancel_event.set()
12
        self.log("🛑 正在停止任务，请稍候...")
13
        self.btn_action.config(state="disabled")
14

15
def reset_ui_state(self):
16
    """重置UI状态"""
17
    self.btn_action.config(text="🚀 开始评估", style="Action.TButton", state="normal")

1
def generate_report_image(result, user_info, output_path):
2
    """
3
    生成评估报告图片
4

5
    参数:
6
        result: 推理结果字典
7
        user_info: 用户信息字典
8
        output_path: 输出文件路径
9

10
    返回:
11
        bool: 是否生成成功
12
    """
13
    try:
14
        # 创建报告画布
15
        from PIL import Image, ImageDraw, ImageFont
16

17
        # 设置画布大小
18
        width, height = 800, 1200
19
        image = Image.new('RGB', (width, height), 'white')
20
        draw = ImageDraw.Draw(image)
21

22
        # 加载字体
23
        try:
24
            font_title = ImageFont.truetype("simhei.ttf", 36)
25
            font_header = ImageFont.truetype("simhei.ttf", 24)
26
            font_normal = ImageFont.truetype("simhei.ttf", 16)
27
            font_small = ImageFont.truetype("simhei.ttf", 12)
28
        except:
29
            font_title = ImageFont.load_default()
30
            font_header = ImageFont.load_default()
31
            font_normal = ImageFont.load_default()
32
            font_small = ImageFont.load_default()
33

34
        # 绘制标题
35
        draw.text((400, 50), "多模态抑郁风险评估报告", fill="#2c3e50", font=font_title, anchor="mm")
36

37
        # 绘制用户信息
38
        draw.text((100, 120), f"报告编号: {user_info.get('report_id', 'N/A')}", fill="#34495e", font=font_normal)
39
        draw.text((100, 160), f"姓名: {user_info.get('name', '未命名')}", fill="#34495e", font=font_normal)
40
        draw.text((400, 160), f"性别: {user_info.get('gender', '未知')}", fill="#34495e", font=font_normal)
41
        draw.text((650, 160), f"年龄: {user_info.get('age', '未知')}", fill="#34495e", font=font_normal)
42

43
        # 绘制评估结果
44
        draw.text((100, 220), "评估结果", fill="#3498db", font=font_header)
45
        draw.rectangle([(80, 260), (720, 380)], outline="#ddd", width=2)
46

47
        severity = result.get('severity', '无法评估')
48
        severity_color = result.get('severity_color', '#44aa44')
49
        draw.text((400, 300), severity, fill=severity_color, font=font_title, anchor="mm")
50

51
        # 绘制详细信息
52
        draw.text((100, 420), "详细信息", fill="#3498db", font=font_header)
53

54
        y_position = 460
55
        draw.text((100, y_position), f"抑郁概率: {result.get('proba', 0):.2%}", fill="#2c3e50", font=font_normal)
56
        y_position += 40
57
        draw.text((100, y_position), f"判定阈值: {result.get('threshold', 0):.2%}", fill="#2c3e50", font=font_normal)
58
        y_position += 40
59
        draw.text((100, y_position), f"PHQ-8分数: {result.get('phq8_score', 0):.1f}", fill="#2c3e50", font=font_normal)
60

61
        # 保存报告
62
        image.save(output_path)
63
        return True
64

65
    except Exception as e:
66
        print(f"报告生成失败: {e}")
67
        return False