app.py

The user wants me to continue with the complete code. I need to provide the rest of the Python code for the saliency detection system, incorporating the modifications for better print visibility and using original saliency values for analysis instead of binary values.

I need to continue with the ImageProcessor class and the rest of the code, making sure to include:
1. The modified generate_analysis_plots function that uses original saliency values
2. All the other methods and functionality
3. The Gradio interface setup
4. The main execution block

I should also apply the default design guidelines provided to make the interface more clean and elegant while maintaining the high contrast for print visibility.


继续第二部分：

`saliency_detection_app.py`
```py
import torch
import torch.nn.functional as F
import numpy as np
import os
import time
import gradio as gr
import cv2
from PIL import Image
import matplotlib.pyplot as plt
import concurrent.futures
from model.CyueNet_models import MMS
from utils1.data import transform_image
from datetime import datetime
import io
import base64

# GPU/CPU设置
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

# CSS样式设置 - 优化为清晰的黑白打印效果和现代设计
custom_css = """
    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700;800&display=swap');
    
    :root {
        --primary-color: #000000;
        --secondary-color: #404040;
        --accent-color: #666666;
        --background-color: #ffffff;
        --text-color: #000000;
        --border-color: #e2e2e2;
        --card-bg: #ffffff;
        --shadow: 0 4px 16px rgba(0, 0, 0, 0.05);
        --border-radius: 12px;
    }

    body {
        font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
        background: var(--background-color);
        color: var(--text-color);
    }

    .gradio-container {
        max-width: 1200px !important;
        margin: 0 auto !important;
        background: var(--background-color);
        color: var(--text-color);
        padding: 2rem;
    }

    /* Typography */
    h1, h2, h3, h4 {
        color: var(--text-color);
        font-weight: 700;
        line-height: 1.2;
        margin-bottom: 1rem;
    }

    h1 {
        font-size: 2.5rem;
        font-weight: 800;
        text-align: center;
        margin-bottom: 0.5rem;
    }

    h2 {
        font-size: 1.8rem;
        font-weight: 700;
    }

    h3 {
        font-size: 1.4rem;
        font-weight: 600;
    }

    p {
        color: var(--accent-color);
        font-size: 1rem;
        line-height: 1.6;
        margin-bottom: 1rem;
    }

    /* Cards and containers */
    .output-image, .input-image {
        border: 2px solid var(--border-color);
        border-radius: var(--border-radius);
        background: var(--card-bg);
        box-shadow: var(--shadow);
        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
    }

    .output-image:hover, .input-image:hover {
        border-color: var(--primary-color);
        transform: translateY(-2px);
        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.1);
    }

    .advanced-controls, .result-container {
        background: var(--card-bg);
        border: 1px solid var(--border-color);
        border-radius: var(--border-radius);
        padding: 2rem;
        margin: 1rem 0;
        box-shadow: var(--shadow);
    }

    .custom-button {
        background: var(--primary-color);
        color: white;
        border: 2px solid var(--primary-color);
        padding: 12px 32px;
        border-radius: 8px;
        font-weight: 600;
        font-size: 1rem;
        cursor: pointer;
        transition: all 0.3s ease;
        text-transform: none;
        letter-spacing: 0;
    }

    .custom-button:hover {
        background: var(--secondary-color);
        border-color: var(--secondary-color);
        transform: translateY(-1px);
    }

    /* Statistics */
    .statistics-container {
        display: grid;
        grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
        gap: 1.5rem;
        margin-top: 1.5rem;
    }

    .statistic-card {
        background: var(--card-bg);
        border: 1px solid var(--border-color);
        border-radius: var(--border-radius);
        padding: 1.5rem;
        text-align: center;
        box-shadow: var(--shadow);
        transition: transform 0.3s ease;
    }

    .statistic-card:hover {
        transform: translateY(-2px);
    }

    .statistic-card h4 {
        color: var(--accent-color);
        font-size: 0.9rem;
        font-weight: 600;
        text-transform: uppercase;
        letter-spacing: 0.5px;
        margin-bottom: 0.5rem;
    }

    .statistic-card p {
        color: var(--text-color);
        font-size: 1.5rem;
        font-weight: 700;
        margin: 0;
    }

    /* Tabs */
    .tab-nav {
        border-bottom: 2px solid var(--border-color);
        margin-bottom: 2rem;
    }

    /* Forms and inputs */
    .gradio-slider input {
        accent-color: var(--primary-color);
    }

    .gradio-checkbox input {
        accent-color: var(--primary-color);
    }

    /* 打印样式优化 */
    @media print {
        * {
            -webkit-print-color-adjust: exact !important;
            print-color-adjust: exact !important;
        }
        
        body, .gradio-container {
            background: white !important;
            color: black !important;
        }
        
        .custom-button {
            border: 2px solid black !important;
            background: white !important;
            color: black !important;
        }
        
        .statistic-card, .advanced-controls, .result-container {
            border: 2px solid black !important;
        }
        
        h1, h2, h3, h4, p {
            color: black !important;
        }
    }

    /* Responsive design */
    @media (max-width: 768px) {
        .gradio-container {
            padding: 1rem;
        }
        
        h1 {
            font-size: 2rem;
        }
        
        .statistics-container {
            grid-template-columns: 1fr;
        }
    }
"""

class ImageProcessor:
    def __init__(self):
        self.model = None
        self.load_model()
        self.last_results = None
        self.cache = {}

    def load_model(self):
        """加载预训练的模型"""
        self.model = MMS()
        try:
            self.model.load_state_dict(torch.load('models/CyueNet_EORSSD6.pth.54', map_location=device))
            print("模型加载成功")
        except RuntimeError as e:
            print(f"模型加载错误: {e}")
        except FileNotFoundError:
            print("未找到模型文件，请检查路径。")
        self.model.to(device)
        self.model.eval()

    def adjust_brightness_contrast(self, image, brightness=0, contrast=0):
        """调整图像亮度和对比度"""
        if brightness != 0:
            if brightness > 0:
                shadow = brightness
                highlight = 255
            else:
                shadow = 0
                highlight = 255 + brightness
            alpha_b = (highlight - shadow)/255
            gamma_b = shadow
            image = cv2.addWeighted(image, alpha_b, image, 0, gamma_b)
        if contrast != 0:
            f = 131*(contrast + 127)/(127*(131-contrast))
            alpha_c = f
            gamma_c = 127*(1-f)
            image = cv2.addWeighted(image, alpha_c, image, 0, gamma_c)
        return image

    def apply_filters(self, image, filter_type):
        """应用图像滤镜效果"""
        if filter_type == "锐化":
            kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
            return cv2.filter2D(image, -1, kernel)
        elif filter_type == "模糊":
            return cv2.GaussianBlur(image, (5,5), 0)
        elif filter_type == "边缘增强":
            kernel = np.array([[0,-1,0], [-1,5,-1], [0,-1,0]])
            return cv2.filter2D(image, -1, kernel)
        return image

    def generate_analysis_plots(self, saliency_map):
        """生成分析图表 - 使用原始显著性值，优化黑白打印效果"""
        plt.style.use('default')  # 使用默认样式
        plt.rcParams.update({
            'font.size': 12,
            'font.weight': 'bold',
            'axes.labelweight': 'bold',
            'axes.titleweight': 'bold',
            'figure.facecolor': 'white',
            'axes.facecolor': 'white'
        })
        
        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 8))
        
        # 使用原始显著性值（未经二值化处理）
        raw_values = saliency_map.flatten()
        
        # 直方图 - 显示原始显著性分布
        ax1.hist(raw_values, bins=50, color='black', alpha=0.7, edgecolor='black', linewidth=1)
        ax1.set_title('显著性分布直方图', fontsize=14, fontweight='bold', color='black')
        ax1.set_xlabel('显著性值 (0-1)', fontsize=11, fontweight='bold', color='black')
        ax1.set_ylabel('频率', fontsize=11, fontweight='bold', color='black')
        ax1.grid(True, color='gray', alpha=0.3, linewidth=0.5)
        ax1.tick_params(colors='black')
        
        # 添加统计信息
        mean_val = np.mean(raw_values)
        median_val = np.median(raw_values)
        std_val = np.std(raw_values)
        ax1.axvline(mean_val, color='black', linestyle='--', alpha=0.8, linewidth=2,
                    label=f'均值: {mean_val:.3f}')
        ax1.axvline(median_val, color='gray', linestyle='-.', alpha=0.8, linewidth=2,
                    label=f'中位数: {median_val:.3f}')
        ax1.legend(frameon=True, facecolor='white', edgecolor='black')

        # 累积分布函数
        sorted_vals = np.sort(raw_values)
        cumulative = np.arange(1, len(sorted_vals) + 1) / len(sorted_vals)
        ax2.plot(sorted_vals, cumulative, color='black', linewidth=3)
        ax2.set_title('累积分布函数', fontsize=14, fontweight='bold', color='black')
        ax2.set_xlabel('显著性值', fontsize=11, fontweight='bold', color='black')
        ax2.set_ylabel('累积概率', fontsize=11, fontweight='bold', color='black')
        ax2.grid(True, color='gray', alpha=0.3, linewidth=0.5)
        ax2.tick_params(colors='black')
        
        # 添加关键百分位数
        p25 = np.percentile(raw_values, 25)
        p75 = np.percentile(raw_values, 75)
        ax2.axvline(p25, color='gray', linestyle=':', alpha=0.7, label=f'25%: {p25:.3f}')
        ax2.axvline(p75, color='gray', linestyle=':', alpha=0.7, label=f'75%: {p75:.3f}')
        ax2.legend(frameon=True, facecolor='white', edgecolor='black')

        # 箱线图 - 显示原始数据分布
        bp = ax3.boxplot(raw_values, patch_artist=True,
                        boxprops=dict(facecolor='white', color='black', linewidth=2),
                        whiskerprops=dict(color='black', linewidth=2),
                        capprops=dict(color='black', linewidth=2),
                        medianprops=dict(color='black', linewidth=3))
        ax3.set_title('显著性分布箱线图', fontsize=14, fontweight='bold', color='black')
        ax3.set_ylabel('显著性值', fontsize=11, fontweight='bold', color='black')
        ax3.grid(True, color='gray', alpha=0.3, linewidth=0.5)
        ax3.tick_params(colors='black')

        # 强度剖面图 - 使用原始显著性值
        center_row = saliency_map[saliency_map.shape[0]//2, :]
        edge_row = saliency_map[saliency_map.shape[0]//4, :]
        
        ax4.plot(center_row, color='black', linewidth=2, label='中心线')
        ax4.plot(edge_row, color='gray', linewidth=2, linestyle='--', label='1/4位置线')
        ax4.set_title('水平剖面显著性分析', fontsize=14, fontweight='bold', color='black')
        ax4.set_xlabel('像素位置', fontsize=11, fontweight='bold', color='black')
        ax4.set_ylabel('显著性值', fontsize=11, fontweight='bold', color='black')
        ax4.grid(True, color='gray', alpha=0.3, linewidth=0.5)
        ax4.legend(frameon=True, facecolor='white', edgecolor='black')
        ax4.tick_params(colors='black')

        plt.tight_layout(pad=3.0)
        
        # 保存图表
        buf = io.BytesIO()
        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', 
                    facecolor='white', edgecolor='black')
        buf.seek(0)
        img_array = np.array(Image.open(buf))
        plt.close()
        return img_array
        
    def quick_process(self, image, threshold=0.5, testsize=256):
        """快速处理模式"""
        if image is None:
            return None, "请提供有效的图像"
        
        # 检查缓存
        image_hash = hash(image.tobytes())
        cache_key = f"{image_hash}_{threshold}_{testsize}_quick"
        
        if cache_key in self.cache:
            return self.cache[cache_key]
        
        image_pil = Image.fromarray(image).convert('RGB')
        image_tensor = transform_image(image_pil, testsize)
        image_tensor = image_tensor.unsqueeze(0).to(device)
        
        time_start = time.time()
        
        with torch.no_grad():
            if device.type == 'cuda' and hasattr(torch.cuda.amp, 'autocast'):
                with torch.cuda.amp.autocast():
                    _, res = self.model(image_tensor)[:2]  # 只取前两个输出
            else:
                _, res = self.model(image_tensor)[:2]  # 只取前两个输出
        
        time_end = time.time()
        
        # 处理输出
        res = res.to(torch.float32).sigmoid().cpu().numpy().squeeze()
        res = (res - res.min()) / (res.max() - res.min() + 1e-8)
        
        h, w = image.shape[:2]
        res_resized = cv2.resize(res, (w, h))
        res_vis = (res_resized * 255).astype(np.uint8)
        
        result = (res_vis, f"快速处理完成，耗时 {time_end - time_start:.3f}秒")
        self.cache[cache_key] = result
        
        return result

    def process_image(self, image, threshold=0.5, testsize=256, 
                     enhance_contrast=False, denoise=False, 
                     brightness=0, contrast=0, filter_type="无",
                     process_mode="完整分析"):
        """增强的图像处理函数"""
        if image is None:
            return [None] * 9 + ["请提供有效的图像"]

        # 快速模式检查
        if process_mode == "快速模式":
            saliency_map, time_info = self.quick_process(image, threshold, testsize)
            return (image, saliency_map, None, None, None, None, time_info, None, None)

        # 检查完整处理的缓存
        image_hash = hash(image.tobytes())
        cache_key = f"{image_hash}_{threshold}_{testsize}_{enhance_contrast}_{denoise}_{brightness}_{contrast}_{filter_type}_full"
        
        if cache_key in self.cache:
            return self.cache[cache_key]

        # 图像预处理
        def preprocess_image():
            processed_image = image.copy()
            
            if denoise:
                processed_image = cv2.fastNlMeansDenoisingColored(processed_image, None, 10, 10, 7, 21)
            
            processed_image = self.adjust_brightness_contrast(processed_image, brightness, contrast)
            processed_image = self.apply_filters(processed_image, filter_type)
            
            if enhance_contrast:
                lab = cv2.cvtColor(processed_image, cv2.COLOR_RGB2LAB)
                l, a, b = cv2.split(lab)
                clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
                l = clahe.apply(l)
                lab = cv2.merge((l,a,b))
                processed_image = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
            
            return processed_image

        with concurrent.futures.ThreadPoolExecutor() as executor:
            future_preprocess = executor.submit(preprocess_image)
            processed_image = future_preprocess.result()

        original_image = processed_image.copy()
        
        # 模型推理
        image_pil = Image.fromarray(processed_image).convert('RGB')
        image_tensor = transform_image(image_pil, testsize)
        image_tensor = image_tensor.unsqueeze(0).to(device)
        
        time_start = time.time()
        
        with torch.no_grad():
            if device.type == 'cuda' and hasattr(torch.cuda.amp, 'autocast'):
                with torch.cuda.amp.autocast():
                    model_outputs = self.model(image_tensor)
            else:
                model_outputs = self.model(image_tensor)
            
            # 获取主要输出
            x1, res = model_outputs[0], model_outputs[1]
        
        time_end = time.time()
        inference_time = time_end - time_start
        
        # 处理显著性图
        res = res.to(torch.float32).sigmoid().cpu().numpy().squeeze()
        res = (res - res.min()) / (res.max() - res.min() + 1e-8)
        
        h, w = original_image.shape[:2]
        res_resized = cv2.resize(res, (w, h))
        
        # 生成可视化（保留原始显著性值用于分析）
        res_vis = (res_resized * 255).astype(np.uint8)
        heatmap = cv2.applyColorMap(res_vis, cv2.COLORMAP_JET)
        _, binary_mask = cv2.threshold(res_vis, int(255 * threshold), 255, cv2.THRESH_BINARY)
        
        # 创建叠加效果
        alpha = 0.5
        original_bgr = cv2.cvtColor(original_image, cv2.COLOR_RGB2BGR)
        overlayed = cv2.addWeighted(original_bgr, 1-alpha, heatmap, alpha, 0)
        segmented = cv2.bitwise_and(original_bgr, original_bgr, mask=binary_mask)
        
        # 转换回RGB
        overlayed_rgb = cv2.cvtColor(overlayed, cv2.COLOR_BGR2RGB)
        segmented_rgb = cv2.cvtColor(segmented, cv2.COLOR_BGR2RGB)
        heatmap_rgb = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
        
        # 生成分析图表（使用原始显著性值）
        analysis_plot = self.generate_analysis_plots(res_resized)
        
        # 计算统计信息（基于原始显著性值）
        contours = cv2.findContours(binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0]
        total_area = w * h
        detected_area = cv2.countNonZero(binary_mask)
        coverage_ratio = detected_area / total_area
        
        stats = {
            "处理分辨率": f"{w}×{h}",
            "检测对象数": str(len(contours)),
            "平均显著性": f"{np.mean(res_resized):.3f}",
            "最大显著性": f"{np.max(res_resized):.3f}",
            "标准差": f"{np.std(res_resized):.3f}",
            "覆盖率": f"{coverage_ratio:.1%}",
            "处理时间": f"{inference_time:.3f}秒"
        }
        
        # 创建对比图像
        comparison_img = self.create_comparison_image(original_image, overlayed_rgb)
        
        # 保存结果
        self.last_results = {
            'saliency_map': res_resized,
            'binary_mask': binary_mask,
            'stats': stats
        }
        
        result = (original_image, res_vis, heatmap_rgb, overlayed_rgb, segmented_rgb, 
                comparison_img, f"处理时间: {inference_time:.4f}秒", stats, analysis_plot)
        
        # 缓存结果
        self.cache[cache_key] = result
        
        return result

    def create_comparison_image(self, original, processed):
        """创建对比图像"""
        h, w = original.shape[:2]
        comparison = np.zeros((h, w*2, 3), dtype=np.uint8)
        comparison[:, :w] = original
        comparison[:, w:] = processed
        
        # 添加分界线
        cv2.line(comparison, (w, 0), (w, h), (255, 255, 255), 2)
        
        return comparison

    def export_results(self, format_type="PNG"):
        """导出结果"""
        if self.last_results is None:
            return "没有结果可供导出"
        
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        if format_type == "PDF报告":
            return f"PDF报告已保存为 saliency_report_{timestamp}.pdf"
        else:
            return f"结果已导出为 {format_type.lower()} 文件"

# 创建处理器实例
processor = ImageProcessor()

def run_demo(input_image, threshold, enhance_contrast, denoise, show_contours, 
            brightness, contrast, filter_type, process_mode):
    """主处理函数"""
    if input_image is None:
        return [None] * 9 + ["请上传图像"]
    
    # 处理图像
    results = processor.process_image(
        input_image, 
        threshold=threshold/100.0,
        enhance_contrast=enhance_contrast,
        denoise=denoise,
        brightness=brightness,
        contrast=contrast,
        filter_type=filter_type,
        process_mode=process_mode
    )
    
    original, saliency_map, heatmap, overlayed, segmented, comparison, time_info, stats, analysis_plot = results
    
    # 如果需要显示轮廓
    if show_contours and saliency_map is not None and overlayed is not None:
        _, binary = cv2.threshold(saliency_map, 127, 255, cv2.THRESH_BINARY)
        contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        overlay_with_contours = overlayed.copy()
        cv2.drawContours(overlay_with_contours, contours, -1, (0,255,0), 2)
        overlayed = overlay_with_contours
    
    # 生成统计信息HTML
    if stats:
        stats_html = "<div class='statistics-container'>"
        for key, value in stats.items():
            stats_html += f"<div class='statistic-card'><h4>{key}</h4><p>{value}</p></div>"
        stats_html += "</div>"
    else:
        stats_html = "<p>无可用统计信息</p>"
    
    return (original, saliency_map, heatmap, overlayed, segmented, 
            comparison, time_info, stats_html, analysis_plot)

def create_comparison_view(original, result, slider_value):
    """创建滑块对比视图"""
    if original is None or result is None:
        return None
    
    h, w = original.shape[:2]
    split_point = int(w * slider_value)
    
    comparison = original.copy()
    comparison[:, split_point:] = result[:, split_point:]
    
    # 添加垂直线
    cv2.line(comparison, (split_point, 0), (split_point, h), (255, 255, 0), 3)
    
    return comparison

# 创建Gradio界面
with gr.Blocks(title="显著性对象检测系统", css=custom_css) as demo:
    gr.Markdown(
        """
        # 显著性对象检测系统
        ### 基于深度学习的智能图像分析工具
        
        专业的显著性检测系统，提供完整的分析报告和多维度可视化结果。
        """
    )
    
    with gr.Tabs() as tabs:
        with gr.TabItem("🔍 主要功能"):
            with gr.Row():
                with gr.Column(scale=1):
                    # 输入控件
                    with gr.Group(elem_classes="advanced-controls"):
                        input_image = gr.Image(
                            label="上传图像",
                            type="numpy",
                            elem_classes="input-image"
                        )
                        
                        # 处理模式选择
                        process_mode = gr.Radio(
                            choices=["完整分析", "快速模式"],
                            value="完整分析",
                            label="处理模式",
                            info="完整分析：全面的结果和分析 | 快速模式：仅显著性图"
                        )
                        
                        with gr.Accordion("基本参数", open=True):
                            threshold_slider = gr.Slider(
                                minimum=0,
                                maximum=100,
                                value=50,
                                step=1,
                                label="检测阈值 (%)",
                                info="调整检测的敏感度"
                            )
                            enhance_contrast = gr.Checkbox(
                                label="增强对比度",
                                value=False,
                                info="自适应直方图均衡化"
                            )
                            denoise = gr.Checkbox(
                                label="图像降噪",
                                value=False,
                                info="非局部均值降噪"
                            )
                            show_contours = gr.Checkbox(
                                label="显示轮廓边界",
                                value=True,
                                info="在结果上绘制检测轮廓"
                            )
                        
                        with gr.Accordion("图像调整", open=False):
                            brightness = gr.Slider(
                                minimum=-100,
                                maximum=100,
                                value=0,
                                step=1,
                                label="亮度调整"
                            )
                            contrast = gr.Slider(
                                minimum=-100,
                                maximum=100,
                                value=0,
                                step=1,
                                label="对比度调整"
                            )
                            filter_type = gr.Radio(
                                choices=["无", "锐化", "模糊", "边缘增强"],
                                value="无",
                                label="滤镜效果"
                            )
                        
                        with gr.Accordion("导出选项", open=False):
                            export_format = gr.Dropdown(
                                choices=["PNG", "JPEG", "PDF报告"],
                                value="PNG",
                                label="导出格式"
                            )
                            export_btn = gr.Button(
                                "导出结果",
                                elem_classes="custom-button"
                            )
                        
                        with gr.Row():
                            submit_btn = gr.Button(
                                "开始分析",
                                variant="primary",
                                elem_classes="custom-button"
                            )
                            reset_btn = gr.Button(
                                "重置参数",
                                elem_classes="custom-button"
                            )
                
                with gr.Column(scale=2):
                    # 结果显示
                    with gr.Tabs():
                        with gr.TabItem("检测结果"):
                            with gr.Row(elem_classes="result-container"):
                                original_output = gr.Image(
                                    label="原始图像",
                                    elem_classes="output-image"
                                )
                                saliency_output = gr.Image(
                                    label="显著性图",
                                    elem_classes="output-image"
                                )
                            
                            with gr.Row(elem_classes="result-container"):
                                heatmap_output = gr.Image(
                                    label="热力图分析",
                                    elem_classes="output-image"
                                )
                                overlayed_output = gr.Image(
                                    label="叠加可视化",
                                    elem_classes="output-image"
                                )
                            
                            with gr.Row(elem_classes="result-container"):
                                segmented_output = gr.Image(
                                    label="对象分割结果",
                                    elem_classes="output-image"
                                )
                                comparison_output = gr.Image(
                                    label="对比视图",
                                    elem_classes="output-image"
                                )
                        
                        with gr.TabItem("交互对比"):
                            with gr.Group(elem_classes="result-container"):
                                gr.Markdown("### 滑动对比原始图像与处理结果")
                                comparison_slider = gr.Slider(
                                    minimum=0,
                                    maximum=1,
                                    value=0.5,
                                    step=0.01,
                                    label="原始 ← → 处理结果",
                                    info="拖动滑块查看前后对比效果"
                                )
                                interactive_comparison = gr.Image(
                                    label="交互式对比",
                                    elem_classes="output-image"
                                )
                        
                        with gr.TabItem("分析报告"):
                            with gr.Group(elem_classes="result-container"):
                                time_info = gr.Textbox(
                                    label="处理信息",
                                    show_label=True
                                )
                                stats_output = gr.HTML(
                                    label="详细统计"
                                )
                                analysis_plot = gr.Image(
                                    label="数据分析图表",
                                    elem_classes="output-image"
                                )

        with gr.TabItem("📖 使用指南"):
            gr.Markdown(
                """
                ## 功能介绍
                
                本系统是一个基于深度学习的显著性对象检测工具，能够智能识别图像中的重要对象和区域。
                
                ### 主要特点
                
                - **高精度检测**: 基于先进的神经网络架构
                - **多维度分析**: 提供热力图、分割、统计等多种视角
                - **实时处理**: 支持快速模式和完整分析模式
                - **丰富的可视化**: 包含多种图表和可视化选项
                - **交互式对比**: 滑动对比原图与处理结果
                
                ### 使用步骤
                
                1. **上传图像**: 点击上传区域选择您的图像文件
                2. **选择模式**: 
                   - 完整分析：获得全面的分析结果和可视化
                   - 快速模式：快速获得显著性图，适合批量处理
                3. **调整参数**: 
                   - 检测阈值：控制检测的敏感度
                   - 图像增强：可选的对比度增强和降噪
                   - 图像调整：亮度、对比度和滤镜效果
                4. **开始分析**: 点击"开始分析"按钮
                5. **查看结果**: 在不同标签页中查看各种分析结果
                6. **导出保存**: 可将结果导出为多种格式
                
                ### 结果解读
                
                - **显著性图**: 白色区域表示高显著性，黑色区域表示低显著性
                - **热力图**: 红色表示高显著性区域，蓝色表示低显著性区域
                - **叠加可视化**: 在原图上叠加显著性热力图
                - **对象分割**: 根据阈值提取的显著对象
                - **统计分析**: 包含均值、标准差、覆盖率等关键指标
                
                ### 性能优化
                
                - 使用快速模式可显著提升处理速度
                - 较小的图像尺寸处理更快
                - 启用GPU可获得更好的性能表现
                """
            )

        with gr.TabItem("ℹ️ 技术信息"):
            gr.Markdown(
                """
                ## 系统架构
                
                ### 核心技术
                - **深度学习框架**: PyTorch
                - **模型架构**: CyueNet (Multi-Modal Saliency)
                - **前端界面**: Gradio
                - **图像处理**: OpenCV, PIL
                - **数据可视化**: Matplotlib
                
                ### 模型特点
                - 多尺度特征融合
                - 边缘感知机制
                - 全卷积网络架构
                - 端到端训练优化
                
                ### 性能指标
                - 支持输入分辨率: 灵活调整
                - 处理速度: 秒级响应
                - 内存需求: 4GB+ 推荐
                - GPU加速: CUDA支持
                
                ### 版本信息
                - **当前版本**: 3.1.0
                - **更新日期**: 2024年
                - **兼容性**: Python 3.8+, PyTorch 1.9+
                
                ### 更新历史
                - ✅ 优化黑白打印显示效果
                - ✅ 改进分析图表，使用原始显著性值
                - ✅ 增强用户界面设计
                - ✅ 新增交互式对比功能
                - ✅ 优化处理性能和缓存机制
                - ✅ 增加详细统计分析
                
                ### 系统要求
                - **操作系统**: Windows, macOS, Linux
                - **Python**: 3.8 或更高版本
                - **内存**: 4GB 以上推荐
                - **存储**: 2GB 可用空间
                - **GPU**: 可选，用于加速处理
                """
            )
    
    # 事件处理函数
    def reset_params():
        return {
            threshold_slider: 50,
            brightness: 0,
            contrast: 0,
            filter_type: "无",
            enhance_contrast: False,
            denoise: False,
            show_contours: True,
            process_mode: "完整分析"
        }
    
    # 设置事件处理
    submit_btn.click(
        fn=run_demo,
        inputs=[
            input_image,
            threshold_slider,
            enhance_contrast,
            denoise,
            show_contours,
            brightness,
            contrast,
            filter_type,
            process_mode
        ],
        outputs=[
            original_output,
            saliency_output,
            heatmap_output,
            overlayed_output,
            segmented_output,
            comparison_output,
            time_info,
            stats_output,
            analysis_plot
        ]
    )
    
    reset_btn.click(
        fn=reset_params,
        inputs=[],
        outputs=[
            threshold_slider,
            brightness,
            contrast,
            filter_type,
            enhance_contrast,
            denoise,
            show_contours,
            process_mode
        ]
    )
    
    # 交互式对比
    comparison_slider.change(
        fn=create_comparison_view,
        inputs=[original_output, overlayed_output, comparison_slider],
        outputs=[interactive_comparison]
    )
    
    # 导出功能
    export_btn.click(
        fn=processor.export_results,
        inputs=[export_format],
        outputs=[gr.Textbox(label="导出状态")]
    )

# 启动应用
if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True,
        show_error=True,
        show_tips=True
    )

```