Update app.py

app.py

@@ -1,3 +1,18 @@
+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
@@ -17,126 +32,208 @@ import base64
 # GPU/CPU设置
 device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
 
-# CSS样式设置
+# CSS样式设置 - 优化为清晰的黑白打印效果和现代设计
 custom_css = """
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700;800&display=swap');
+    
     :root {
-        --primary-color: #2196F3;
-        --secondary-color: #21CBF3;
-        --background-color: #f6f8fa;
-        --text-color: #333;
-        --border-radius: 10px;
-        --glass-bg: rgba(255, 255, 255, 0.25);
-        --shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+        --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 {
-        background: linear-gradient(135deg, var(--background-color), #ffffff);
-        max-width: 1400px !important;
-        margin: auto !important;
-        backdrop-filter: blur(10px);
+        max-width: 1200px !important;
+        margin: 0 auto !important;
+        background: var(--background-color);
+        color: var(--text-color);
+        padding: 2rem;
     }
 
-    .output-image, .input-image {
-        border-radius: var(--border-radius);
-        box-shadow: var(--shadow);
-        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-        backdrop-filter: blur(10px);
-        border: 1px solid rgba(255, 255, 255, 0.18);
+    /* Typography */
+    h1, h2, h3, h4 {
+        color: var(--text-color);
+        font-weight: 700;
+        line-height: 1.2;
+        margin-bottom: 1rem;
     }
 
-    .output-image:hover, .input-image:hover {
-        transform: scale(1.02) translateY(-2px);
-        box-shadow: 0 12px 40px 0 rgba(31, 38, 135, 0.5);
+    h1 {
+        font-size: 2.5rem;
+        font-weight: 800;
+        text-align: center;
+        margin-bottom: 0.5rem;
     }
 
-    .custom-button {
-        background: linear-gradient(45deg, var(--primary-color), var(--secondary-color));
-        border: none;
-        color: white;
-        padding: 12px 24px;
-        border-radius: var(--border-radius);
-        cursor: pointer;
-        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-        font-weight: bold;
-        text-transform: uppercase;
-        letter-spacing: 1px;
-        box-shadow: var(--shadow);
+    h2 {
+        font-size: 1.8rem;
+        font-weight: 700;
     }
 
-    .custom-button:hover {
-        transform: translateY(-3px);
-        box-shadow: 0 12px 30px rgba(33, 150, 243, 0.4);
+    h3 {
+        font-size: 1.4rem;
+        font-weight: 600;
     }
 
-    .advanced-controls {
-        background: var(--glass-bg);
-        border-radius: 20px;
-        padding: 25px;
-        box-shadow: var(--shadow);
-        backdrop-filter: blur(10px);
-        border: 1px solid rgba(255, 255, 255, 0.18);
+    p {
+        color: var(--accent-color);
+        font-size: 1rem;
+        line-height: 1.6;
+        margin-bottom: 1rem;
     }
 
-    .result-container {
-        background: var(--glass-bg);
-        border-radius: 20px;
-        padding: 20px;
-        backdrop-filter: blur(15px);
-        border: 1px solid rgba(255, 255, 255, 0.18);
+    /* 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);
     }
 
-    .interactive-viz {
-        border-radius: 15px;
-        overflow: hidden;
-        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);
     }
 
-    .interactive-viz:hover {
-        transform: translateY(-5px);
-        box-shadow: 0 15px 35px rgba(0,0,0,0.15);
+    .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(200px, 1fr));
-        gap: 15px;
-        margin-top: 15px;
+        grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+        gap: 1.5rem;
+        margin-top: 1.5rem;
     }
 
     .statistic-card {
-        background: var(--glass-bg);
-        padding: 20px;
+        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);
-        backdrop-filter: blur(10px);
-        border: 1px solid rgba(255, 255, 255, 0.18);
-        transition: all 0.3s ease;
+        transition: transform 0.3s ease;
     }
 
     .statistic-card:hover {
         transform: translateY(-2px);
-        box-shadow: 0 10px 25px rgba(0,0,0,0.1);
     }
 
-    .progress-container {
-        background: var(--glass-bg);
-        border-radius: 10px;
-        padding: 15px;
-        margin: 10px 0;
-        backdrop-filter: blur(10px);
+    .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;
     }
 
-    .comparison-slider {
-        background: var(--glass-bg);
-        border-radius: 15px;
-        padding: 20px;
-        backdrop-filter: blur(10px);
-        border: 1px solid rgba(255, 255, 255, 0.18);
+    .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
@@ -189,53 +286,94 @@ class ImageProcessor:
         return image
 
     def generate_analysis_plots(self, saliency_map):
-        """生成分析图表"""
-        plt.style.use('seaborn-v0_8')
+        """生成分析图表 - 使用原始显著性值，优化黑白打印效果"""
+        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))
-        # 直方图
-        ax1.hist(saliency_map.flatten(), bins=50, color='#2196F3', alpha=0.7, edgecolor='black')
-        ax1.set_title('Histogram of Saliency Distribution', fontsize=12, pad=15)
-        ax1.set_xlabel('Saliency Value', fontsize=10)
-        ax1.set_ylabel('Frequency', fontsize=10)
-        ax1.grid(True, alpha=0.3)
+        
+        # 使用原��显著性值（未经二值化处理）
+        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(saliency_map)
-        median_val = np.median(saliency_map)
-        ax1.axvline(mean_val, color='red', linestyle='--', alpha=0.7, label=f'Mean: {mean_val:.3f}')
-        ax1.axvline(median_val, color='green', linestyle='--', alpha=0.7, label=f'Median: {median_val:.3f}')
-        ax1.legend()
-        # 累积分布
-        sorted_vals = np.sort(saliency_map.flatten())
+        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='#FF6B35', linewidth=2)
-        ax2.set_title('Cumulative Distribution Function', fontsize=12)
-        ax2.set_xlabel('Saliency Value', fontsize=10)
-        ax2.set_ylabel('Cumulative Probability', fontsize=10)
-        ax2.grid(True, alpha=0.3)
-        # 箱线图
-        ax3.boxplot(saliency_map.flatten(), patch_artist=True, 
-                   boxprops=dict(facecolor='#21CBF3', alpha=0.7))
-        ax3.set_title('Boxplot of Saliency Distribution', fontsize=12)
-        ax3.set_ylabel('Saliency Value', fontsize=10)
-        ax3.grid(True, alpha=0.3)
-        # 强度剖面（中心线）
+        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, :]
-        ax4.plot(center_row, color='#9C27B0', linewidth=2)
-        ax4.set_title('Intensity Profile along Center Line', fontsize=12)
-        ax4.set_xlabel('Pixel Position', fontsize=10)
-        ax4.set_ylabel('Saliency Value', fontsize=10)
-        ax4.grid(True, alpha=0.3)
-        plt.tight_layout()
-        # 保存为字节
+        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')
+        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, "请提供有效的图像"
         
@@ -253,17 +391,15 @@ class ImageProcessor:
         time_start = time.time()
         
         with torch.no_grad():
-            # 关键修改：只计算必要的输出，避免完整模型计算
-            if device.type == 'cuda':
+            if device.type == 'cuda' and hasattr(torch.cuda.amp, 'autocast'):
                 with torch.cuda.amp.autocast():
-                    _, res = self.model.forward_quick(image_tensor)  # 使用简化版前向传播
+                    _, res = self.model(image_tensor)[:2]  # 只取前两个输出
             else:
-                with torch.amp.autocast(device_type='cpu'):
-                    _, res = self.model.forward_quick(image_tensor)  # 使用简化版前向传播
+                _, res = self.model(image_tensor)[:2]  # 只取前两个输出
         
         time_end = time.time()
         
-        # 确保转换为float32类型
+        # 处理输出
         res = res.to(torch.float32).sigmoid().cpu().numpy().squeeze()
         res = (res - res.min()) / (res.max() - res.min() + 1e-8)
         
@@ -276,7 +412,6 @@ class ImageProcessor:
         
         return result
 
-
     def process_image(self, image, threshold=0.5, testsize=256, 
                      enhance_contrast=False, denoise=False, 
                      brightness=0, contrast=0, filter_type="无",
@@ -297,7 +432,7 @@ class ImageProcessor:
         if cache_key in self.cache:
             return self.cache[cache_key]
 
-        # 使用线程进行图像预处理
+        # 图像预处理
         def preprocess_image():
             processed_image = image.copy()
             
@@ -331,24 +466,26 @@ class ImageProcessor:
         time_start = time.time()
         
         with torch.no_grad():
-            if device.type == 'cuda':
+            if device.type == 'cuda' and hasattr(torch.cuda.amp, 'autocast'):
                 with torch.cuda.amp.autocast():
-                    x1, res, s1_sig, edg1, edg_s, s2, e2, s2_sig, e2_sig, s3, e3, s3_sig, e3_sig, s4, e4, s4_sig, e4_sig, s5, e5, s5_sig, e5_sig, sk1, sk1_sig, sk2, sk2_sig, sk3, sk3_sig, sk4, sk4_sig, sk5, sk5_sig = self.model(image_tensor)
+                    model_outputs = self.model(image_tensor)
             else:
-                with torch.amp.autocast(device_type='cpu'):
-                    x1, res, s1_sig, edg1, edg_s, s2, e2, s2_sig, e2_sig, s3, e3, s3_sig, e3_sig, s4, e4, s4_sig, e4_sig, s5, e5, s5_sig, e5_sig, sk1, sk1_sig, sk2, sk2_sig, sk3, sk3_sig, sk4, sk4_sig, sk5, sk5_sig = self.model(image_tensor)
+                model_outputs = self.model(image_tensor)
+            
+            # 获取主要输出
+            x1, res = model_outputs[0], model_outputs[1]
         
         time_end = time.time()
         inference_time = time_end - time_start
         
-        # 确保转换为float32类型
+        # 处理显著性图
         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)
@@ -364,21 +501,22 @@ class ImageProcessor:
         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}x{h}",
-            "检测到对象数": str(len(contours)),
-            "平均置信度": f"{np.mean(res_resized):.2%}",
-            "最大置信度": f"{np.max(res_resized):.2%}",
-            "覆盖率": f"{coverage_ratio:.2%}",
+            "处理分辨率": 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}秒"
         }
         
@@ -420,11 +558,11 @@ class ImageProcessor:
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         
         if format_type == "PDF报告":
-            # 生成PDF报告逻辑
             return f"PDF报告已保存为 saliency_report_{timestamp}.pdf"
         else:
             return f"结果已导出为 {format_type.lower()} 文件"
-# Create processor instance
+
+# 创建处理器实例
 processor = ImageProcessor()
 
 def run_demo(input_image, threshold, enhance_contrast, denoise, show_contours, 
@@ -483,23 +621,25 @@ def create_comparison_view(original, result, slider_value):
     
     return comparison
 
-# Create Gradio interface
-with gr.Blocks(title="高级显著性对象检测系统", css=custom_css) as demo:
+# 创建Gradio界面
+with gr.Blocks(title="显著性对象检测系统", css=custom_css) as demo:
     gr.Markdown(
         """
-        # 🎯 高级显著性对象检测系统
-        ### AI驱动的图像显著性检测与分析工具
+        # 显著性对象检测系统
+        ### 基于深度学习的智能图像分析工具
+        
+        专业的显著性检测系统，提供完整的分析报告和多维度可视化结果。
         """
     )
     
     with gr.Tabs() as tabs:
-        with gr.TabItem("🔍 主功能"):
+        with gr.TabItem("🔍 主要功能"):
             with gr.Row():
                 with gr.Column(scale=1):
                     # 输入控件
                     with gr.Group(elem_classes="advanced-controls"):
                         input_image = gr.Image(
-                            label="输入图像",
+                            label="上传图像",
                             type="numpy",
                             elem_classes="input-image"
                         )
@@ -509,29 +649,32 @@ with gr.Blocks(title="高级显著性对象检测系统", css=custom_css) as dem
                             choices=["完整分析", "快速模式"],
                             value="完整分析",
                             label="处理模式",
-                            info="快速模式仅输出显著性图，处理速度更快"
+                            info="完整分析：全面的结果和分析 | 快速模式：仅显著性图"
                         )
                         
-                        with gr.Accordion("基本设置", open=True):
+                        with gr.Accordion("基本参数", open=True):
                             threshold_slider = gr.Slider(
                                 minimum=0,
                                 maximum=100,
                                 value=50,
                                 step=1,
-                                label="检测阈值",
-                                info="调整检测灵敏度"
+                                label="检测阈值 (%)",
+                                info="调整检测的敏感度"
                             )
                             enhance_contrast = gr.Checkbox(
                                 label="增强对比度",
-                                value=False
+                                value=False,
+                                info="自适应直方图均衡化"
                             )
                             denoise = gr.Checkbox(
-                                label="降噪",
-                                value=False
+                                label="图像降噪",
+                                value=False,
+                                info="非局部均值降噪"
                             )
                             show_contours = gr.Checkbox(
-                                label="显示轮廓",
-                                value=True
+                                label="显示轮廓边界",
+                                value=True,
+                                info="在结果上绘制检测轮廓"
                             )
                         
                         with gr.Accordion("图像调整", open=False):
@@ -540,19 +683,19 @@ with gr.Blocks(title="高级显著性对象检测系统", css=custom_css) as dem
                                 maximum=100,
                                 value=0,
                                 step=1,
-                                label="亮度"
+                                label="亮度调整"
                             )
                             contrast = gr.Slider(
                                 minimum=-100,
                                 maximum=100,
                                 value=0,
                                 step=1,
-                                label="对比度"
+                                label="对比度调整"
                             )
                             filter_type = gr.Radio(
                                 choices=["无", "锐化", "模糊", "边缘增强"],
                                 value="无",
-                                label="图像滤镜"
+                                label="滤镜效果"
                             )
                         
                         with gr.Accordion("导出选项", open=False):
@@ -568,7 +711,7 @@ with gr.Blocks(title="高级显著性对象检测系统", css=custom_css) as dem
                         
                         with gr.Row():
                             submit_btn = gr.Button(
-                                "开始检测",
+                                "开始分析",
                                 variant="primary",
                                 elem_classes="custom-button"
                             )
@@ -597,117 +740,142 @@ with gr.Blocks(title="高级显著性对象检测系统", css=custom_css) as dem
                                     elem_classes="output-image"
                                 )
                                 overlayed_output = gr.Image(
-                                    label="叠加效果",
+                                    label="叠加可视化",
                                     elem_classes="output-image"
                                 )
                             
                             with gr.Row(elem_classes="result-container"):
                                 segmented_output = gr.Image(
-                                    label="对象分割",
+                                    label="对象分割结果",
                                     elem_classes="output-image"
                                 )
                                 comparison_output = gr.Image(
-                                    label="并排对比",
+                                    label="对比视图",
                                     elem_classes="output-image"
                                 )
                         
-                        with gr.TabItem("交互式对比"):
-                            with gr.Group(elem_classes="comparison-slider"):
+                        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="拖动滑块对比原始图像和处理结果"
+                                    label="原始 ← → 处理结果",
+                                    info="拖动滑块查看前后对比效果"
                                 )
                                 interactive_comparison = gr.Image(
-                                    label="交互式对比视图",
-                                    elem_classes="interactive-viz"
+                                    label="交互式对比",
+                                    elem_classes="output-image"
                                 )
                         
                         with gr.TabItem("分析报告"):
                             with gr.Group(elem_classes="result-container"):
                                 time_info = gr.Textbox(
-                                    label="处理时间",
+                                    label="处理信息",
                                     show_label=True
                                 )
                                 stats_output = gr.HTML(
-                                    label="统计信息"
+                                    label="详细统计"
                                 )
                                 analysis_plot = gr.Image(
-                                    label="详细分析图表",
+                                    label="数据分析图表",
                                     elem_classes="output-image"
                                 )
 
-        with gr.TabItem("📖 用户指南"):
+        with gr.TabItem("📖 使用指南"):
             gr.Markdown(
                 """
-                ## 使用说明
-                1. **上传图像**：点击"输入图像"区域上传您的图像
-                2. **选择模式**：选择"完整分析"或"快速模式"
-                   - 完整分析：完整处理流程，包含所有可视化结果
-                   - 快速模式：快速处理，仅输出显著性图
-                3. **调整参数**： 
-                   - 使用阈值滑块调整检测灵敏度
-                   - 根据需要启用对比度增强或降噪
-                   - 在高级设置中微调亮度、对比度和滤镜
-                4. **开始检测**：点击"开始检测"按钮开始分析
-                5. **查看结果**：在不同标���页查看各种可视化结果
-                6. **导出**：使用导出选项保存您的结果
+                ## 功能介绍
                 
-                ## 功能特点
-                - **显著性图**：显示图像区域的显著性分布
-                - **热力图**：彩色编码的强度可视化
-                - **叠加效果**：在原始图像上叠加检测结果
-                - **对象分割**：提取关键对象区域
-                - **交互式对比**：滑动比较原始图像和处理结果
-                - **分析报告**：详细的统计信息和分析图表
+                本系统是一个基于深度学习的显著性对象检测工具，能够智能识别图像中的重要对象和区域。
                 
-                ## 性能提示
-                - 当只需要显著性图时使用快速模式
-                - 分辨率较低的图像处理速度更快
-                - 启用GPU可获得更好的性能
+                ### 主要特点
+                
+                - **高精度检测**: 基于先进的神经网络架构
+                - **多维度分析**: 提供热力图、分割、统计等多种视角
+                - **实时处理**: 支持快速模式和完整分析模式
+                - **丰富的可视化**: 包含多种图表和可视化选项
+                - **交互式对比**: 滑动对比原图与处理结果
+                
+                ### 使用步骤
+                
+                1. **上传图像**: 点击上传区域选择您的图像文件
+                2. **选择模式**: 
+                   - 完整分析：获得全面的分析结果和可视化
+                   - 快速模式：快速获得显著性图，适合批量处理
+                3. **调整参数**: 
+                   - 检测阈值：控制检测的敏感度
+                   - 图像增强：可选的对比度增强和降噪
+                   - 图像调整：亮度、对比度和滤镜效果
+                4. **开始分析**: 点击"开始分析"按钮
+                5. **查看结果**: 在不同标签页中查看各种分析结果
+                6. **导出保存**: 可将结果导出为多种格式
+                
+                ### 结果解读
+                
+                - **显著性图**: 白色区域表示高显著性，黑色区域表示低显著性
+                - **热力图**: 红色表示高显著性区域，蓝色表示低显著性区域
+                - **叠加可视化**: 在原图上叠加显著性热力图
+                - **对象分割**: 根据阈值提取的显著对象
+                - **统计分析**: 包含均值、标准差、覆盖率等关键指标
+                
+                ### 性能优化
+                
+                - 使用快速模式可显著提升处理速度
+                - 较小的图像尺寸处理更快
+                - 启用GPU可获得更好的性能表现
                 """
             )
 
-        with gr.TabItem("ℹ️ 关于"):
+        with gr.TabItem("ℹ️ 技术信息"):
             gr.Markdown(
                 """
-                ## 项目信息
-                - **版本**：3.0.0
-                - **架构**：PyTorch + Gradio
-                - **模型**：CyueNet
-                - **语言**：多语言支持
+                ## 系统架构
+                
+                ### 核心技术
+                - **深度学习框架**: PyTorch
+                - **模型架构**: CyueNet (Multi-Modal Saliency)
+                - **前端界面**: Gradio
+                - **图像处理**: OpenCV, PIL
+                - **数据可视化**: Matplotlib
+                
+                ### 模型特点
+                - 多尺度特征融合
+                - 边缘感知机制
+                - 全卷积网络架构
+                - 端到端训练优化
                 
-                ## 主要特点
-                - 实时图像处理和分析
-                - 多维结果可视化
-                - 丰富的图像调整选项
-                - 详细的数据分析报告
-                - 交互式对比工具
-                - 导出功能
-                - 缓存优化性能
+                ### 性能指标
+                - 支持输入分辨率: 灵活调整
+                - 处理速度: 秒级响应
+                - 内存需求: 4GB+ 推荐
+                - GPU加速: CUDA支持
                 
-                ## 更新日志
-                - ✅ 新增快速模式，提高处理速度
-                - ✅ 增强图像预处理选项
-                - ✅ 新增统计分析功能
-                - ✅ 改进用户界面，采用玻璃拟态设计
-                - ✅ 增加交互式对比滑块
-                - ✅ 使用缓存和线程优化性能
-                - ✅ 多语言图表支持
-                - ✅ 导出功能
+                ### 版本信息
+                - **当前版本**: 3.1.0
+                - **更新日期**: 2024年
+                - **兼容性**: Python 3.8+, PyTorch 1.9+
                 
-                ## 系统要求
-                - Python 3.8+
-                - PyTorch 1.9+
-                - CUDA（可选，用于GPU加速）
-                - 推荐4GB以上内存
+                ### 更新历史
+                - ✅ 优化黑白打印显示效果
+                - ✅ 改进分析图表，使用原始显著性值
+                - ✅ 增强用户界面设计
+                - ✅ 新增交互式对比功能
+                - ✅ 优化处理性能和缓存机制
+                - ✅ 增加详细统计分析
+                
+                ### 系统要求
+                - **操作系统**: Windows, macOS, Linux
+                - **Python**: 3.8 或更高版本
+                - **内存**: 4GB 以上推荐
+                - **存储**: 2GB 可用空间
+                - **GPU**: 可选，用于加速处理
                 """
             )
     
-    # 事件处理
+    # 事件处理函数
     def reset_params():
         return {
             threshold_slider: 50,
@@ -782,5 +950,8 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=True,
-        show_error=True
+        show_error=True,
+        show_tips=True
     )
+
+```