Update app.py

app.py

@@ -149,11 +149,11 @@ class ImageProcessor:
         self.model = MMS()
         try:
             self.model.load_state_dict(torch.load('models/CyueNet_EORSSD6.pth.54', map_location=device))
-            print("Model loaded successfully")
+            print("模型加载成功")
         except RuntimeError as e:
-            print(f"Model loading error: {e}")
+            print(f"模型加载错误: {e}")
         except FileNotFoundError:
-            print("Model file not found. Please check the path.")
+            print("未找到模型文件，请检查路径。")
         self.model.to(device)
         self.model.eval()
 
@@ -178,62 +178,62 @@ class ImageProcessor:
 
     def apply_filters(self, image, filter_type):
         """应用图像滤镜效果"""
-        if filter_type == "Sharpen":
+        if filter_type == "锐化":
             kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
             return cv2.filter2D(image, -1, kernel)
-        elif filter_type == "Blur":
+        elif filter_type == "模糊":
             return cv2.GaussianBlur(image, (5,5), 0)
-        elif filter_type == "Edge Enhancement":
+        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('seaborn-v0_8')
         fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 8))
         
-        # Histogram
+        # 直方图
         ax1.hist(saliency_map.flatten(), bins=50, color='#2196F3', alpha=0.7, edgecolor='black')
-        ax1.set_title('Saliency Distribution Histogram', fontsize=12, pad=15)
-        ax1.set_xlabel('Saliency Value', fontsize=10)
-        ax1.set_ylabel('Frequency', fontsize=10)
+        ax1.set_title('显著性分布直方图', fontsize=12, pad=15)
+        ax1.set_xlabel('显著性值', fontsize=10)
+        ax1.set_ylabel('频率', fontsize=10)
         ax1.grid(True, alpha=0.3)
         
-        # Add statistics
+        # 添加统计信息
         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.axvline(mean_val, color='red', linestyle='--', alpha=0.7, label=f'均值: {mean_val:.3f}')
+        ax1.axvline(median_val, color='green', linestyle='--', alpha=0.7, label=f'中位数: {median_val:.3f}')
         ax1.legend()
         
-        # Cumulative distribution
+        # 累积分布
         sorted_vals = np.sort(saliency_map.flatten())
         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.set_title('累积分布函数', fontsize=12)
+        ax2.set_xlabel('显著性值', fontsize=10)
+        ax2.set_ylabel('累积概率', fontsize=10)
         ax2.grid(True, alpha=0.3)
         
-        # Box plot
+        # 箱线图
         ax3.boxplot(saliency_map.flatten(), patch_artist=True, 
                    boxprops=dict(facecolor='#21CBF3', alpha=0.7))
-        ax3.set_title('Saliency Distribution Box Plot', fontsize=12)
-        ax3.set_ylabel('Saliency Value', fontsize=10)
+        ax3.set_title('显著性分布箱线图', fontsize=12)
+        ax3.set_ylabel('显著性值', fontsize=10)
         ax3.grid(True, alpha=0.3)
         
-        # Intensity profile (center line)
+        # 强度剖面（中心线）
         center_row = saliency_map[saliency_map.shape[0]//2, :]
         ax4.plot(center_row, color='#9C27B0', linewidth=2)
-        ax4.set_title('Center Line Intensity Profile', fontsize=12)
-        ax4.set_xlabel('Pixel Position', fontsize=10)
-        ax4.set_ylabel('Saliency Value', fontsize=10)
+        ax4.set_title('中心线强度剖面', fontsize=12)
+        ax4.set_xlabel('像素位置', fontsize=10)
+        ax4.set_ylabel('显著性值', fontsize=10)
         ax4.grid(True, alpha=0.3)
         
         plt.tight_layout()
         
-        # Save to bytes
+        # 保存为字节
         buf = io.BytesIO()
         plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
         buf.seek(0)
@@ -245,9 +245,9 @@ class ImageProcessor:
     def quick_process(self, image, threshold=0.5, testsize=256):
         """快速处理模式，只输出显著性图"""
         if image is None:
-            return None, "Please provide a valid image"
+            return None, "请提供有效的图像"
         
-        # Check cache
+        # 检查缓存
         image_hash = hash(image.tobytes())
         cache_key = f"{image_hash}_{threshold}_{testsize}_quick"
         
@@ -278,31 +278,31 @@ class ImageProcessor:
         res_resized = cv2.resize(res, (w, h))
         res_vis = (res_resized * 255).astype(np.uint8)
         
-        result = (res_vis, f"Quick processing completed in {time_end - time_start:.3f}s")
+        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="None",
-                     process_mode="Full Analysis"):
+                     brightness=0, contrast=0, filter_type="无",
+                     process_mode="完整分析"):
         """增强的图像处理函数"""
         if image is None:
-            return [None] * 9 + ["Please provide a valid image"]
+            return [None] * 9 + ["请提供有效的图像"]
 
-        # Quick mode check
-        if process_mode == "Quick Mode":
+        # 快速模式检查
+        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)
 
-        # Check cache for full processing
+        # 检查完整处理的缓存
         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]
 
-        # Image preprocessing with threading
+        # 使用线程进行图像预处理
         def preprocess_image():
             processed_image = image.copy()
             
@@ -328,7 +328,7 @@ class ImageProcessor:
 
         original_image = processed_image.copy()
         
-        # Model inference
+        # 模型推理
         image_pil = Image.fromarray(processed_image).convert('RGB')
         image_tensor = transform_image(image_pil, testsize)
         image_tensor = image_tensor.unsqueeze(0).to(device)
@@ -353,44 +353,44 @@ class ImageProcessor:
         h, w = original_image.shape[:2]
         res_resized = cv2.resize(res, (w, h))
         
-        # Generate visualizations
+        # 生成可视化
         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)
         
-        # Create overlays
+        # 创建叠加效果
         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)
         
-        # Convert back to RGB
+        # 转换回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)
         
-        # Generate analysis plots
+        # 生成分析图表
         analysis_plot = self.generate_analysis_plots(res_resized)
         
-        # Calculate statistics
+        # 计算统计信息
         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 = {
-            "Processing Resolution": f"{w}x{h}",
-            "Detected Objects": str(len(contours)),
-            "Average Confidence": f"{np.mean(res_resized):.2%}",
-            "Max Confidence": f"{np.max(res_resized):.2%}",
-            "Coverage Ratio": f"{coverage_ratio:.2%}",
-            "Processing Time": f"{inference_time:.3f}s"
+            "处理分辨率": f"{w}x{h}",
+            "检测到对象数": str(len(contours)),
+            "平均置信度": f"{np.mean(res_resized):.2%}",
+            "最大置信度": f"{np.max(res_resized):.2%}",
+            "覆盖率": f"{coverage_ratio:.2%}",
+            "处理时间": f"{inference_time:.3f}秒"
         }
         
-        # Create comparison image
+        # 创建对比图像
         comparison_img = self.create_comparison_image(original_image, overlayed_rgb)
         
-        # Save results
+        # 保存结果
         self.last_results = {
             'saliency_map': res_resized,
             'binary_mask': binary_mask,
@@ -398,9 +398,9 @@ class ImageProcessor:
         }
         
         result = (original_image, res_vis, heatmap_rgb, overlayed_rgb, segmented_rgb, 
-                comparison_img, f"Processing time: {inference_time:.4f}s", stats, analysis_plot)
+                comparison_img, f"处理时间: {inference_time:.4f}秒", stats, analysis_plot)
         
-        # Cache result
+        # 缓存结果
         self.cache[cache_key] = result
         
         return result
@@ -412,7 +412,7 @@ class ImageProcessor:
         comparison[:, :w] = original
         comparison[:, w:] = processed
         
-        # Add dividing line
+        # 添加分界线
         cv2.line(comparison, (w, 0), (w, h), (255, 255, 255), 2)
         
         return comparison
@@ -420,15 +420,15 @@ class ImageProcessor:
     def export_results(self, format_type="PNG"):
         """导出结果"""
         if self.last_results is None:
-            return "No results to export"
+            return "没有结果可供导出"
         
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         
-        if format_type == "PDF Report":
-            # Generate PDF report logic here
-            return f"PDF report saved as saliency_report_{timestamp}.pdf"
+        if format_type == "PDF报告":
+            # 生成PDF报告逻辑
+            return f"PDF报告已保存为 saliency_report_{timestamp}.pdf"
         else:
-            return f"Results exported as {format_type.lower()} files"
+            return f"结果已导出为 {format_type.lower()} 文件"
 # Create processor instance
 processor = ImageProcessor()
 
@@ -436,9 +436,9 @@ 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 + ["Please upload an image"]
+        return [None] * 9 + ["请上传图像"]
     
-    # Process image
+    # 处理图像
     results = processor.process_image(
         input_image, 
         threshold=threshold/100.0,
@@ -452,7 +452,7 @@ def run_demo(input_image, threshold, enhance_contrast, denoise, show_contours,
     
     original, saliency_map, heatmap, overlayed, segmented, comparison, time_info, stats, analysis_plot = results
     
-    # Add contours if requested
+    # 如果需要显示轮廓
     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)
@@ -460,14 +460,14 @@ def run_demo(input_image, threshold, enhance_contrast, denoise, show_contours,
         cv2.drawContours(overlay_with_contours, contours, -1, (0,255,0), 2)
         overlayed = overlay_with_contours
     
-    # Generate statistics HTML
+    # 生成统计信息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>No statistics available</p>"
+        stats_html = "<p>无可用统计信息</p>"
     
     return (original, saliency_map, heatmap, overlayed, segmented, 
             comparison, time_info, stats_html, analysis_plot)
@@ -483,249 +483,249 @@ def create_comparison_view(original, result, slider_value):
     comparison = original.copy()
     comparison[:, split_point:] = result[:, split_point:]
     
-    # Add vertical line
+    # 添加垂直线
     cv2.line(comparison, (split_point, 0), (split_point, h), (255, 255, 0), 3)
     
     return comparison
 
 # Create Gradio interface
-with gr.Blocks(title="Advanced Saliency Object Detection System", css=custom_css) as demo:
+with gr.Blocks(title="高级显著性对象检测系统", css=custom_css) as demo:
     gr.Markdown(
         """
-        # 🎯 Advanced Saliency Object Detection System
-        ### AI-Powered Image Saliency Detection and Analysis Tool
+        # 🎯 高级显著性对象检测系统
+        ### AI驱动的图像显著性检测与分析工具
         """
     )
     
     with gr.Tabs() as tabs:
-        with gr.TabItem("🔍 Main Functions"):
+        with gr.TabItem("🔍 主功能"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    # Input controls
+                    # 输入控件
                     with gr.Group(elem_classes="advanced-controls"):
                         input_image = gr.Image(
-                            label="Input Image",
+                            label="输入图像",
                             type="numpy",
                             elem_classes="input-image"
                         )
                         
-                        # Processing mode selection
+                        # 处理模式选择
                         process_mode = gr.Radio(
-                            choices=["Full Analysis", "Quick Mode"],
-                            value="Full Analysis",
-                            label="Processing Mode",
-                            info="Quick mode only outputs saliency map for faster processing"
+                            choices=["完整分析", "快速模式"],
+                            value="完整分析",
+                            label="处理模式",
+                            info="快速模式仅输出显著性图，处理速度更快"
                         )
                         
-                        with gr.Accordion("Basic Settings", open=True):
+                        with gr.Accordion("基本设置", open=True):
                             threshold_slider = gr.Slider(
                                 minimum=0,
                                 maximum=100,
                                 value=50,
                                 step=1,
-                                label="Detection Threshold",
-                                info="Adjust detection sensitivity"
+                                label="检测阈值",
+                                info="调整检测灵敏度"
                             )
                             enhance_contrast = gr.Checkbox(
-                                label="Enhance Contrast",
+                                label="增强对比度",
                                 value=False
                             )
                             denoise = gr.Checkbox(
-                                label="Noise Reduction",
+                                label="降噪",
                                 value=False
                             )
                             show_contours = gr.Checkbox(
-                                label="Show Contours",
+                                label="显示轮廓",
                                 value=True
                             )
                         
-                        with gr.Accordion("Image Adjustments", open=False):
+                        with gr.Accordion("图像调整", open=False):
                             brightness = gr.Slider(
                                 minimum=-100,
                                 maximum=100,
                                 value=0,
                                 step=1,
-                                label="Brightness"
+                                label="亮度"
                             )
                             contrast = gr.Slider(
                                 minimum=-100,
                                 maximum=100,
                                 value=0,
                                 step=1,
-                                label="Contrast"
+                                label="对比度"
                             )
                             filter_type = gr.Radio(
-                                choices=["None", "Sharpen", "Blur", "Edge Enhancement"],
-                                value="None",
-                                label="Image Filter"
+                                choices=["无", "锐化", "模糊", "边缘增强"],
+                                value="无",
+                                label="图像滤镜"
                             )
                         
-                        with gr.Accordion("Export Options", open=False):
+                        with gr.Accordion("导出选项", open=False):
                             export_format = gr.Dropdown(
-                                choices=["PNG", "JPEG", "PDF Report"],
+                                choices=["PNG", "JPEG", "PDF报告"],
                                 value="PNG",
-                                label="Export Format"
+                                label="导出格式"
                             )
                             export_btn = gr.Button(
-                                "Export Results",
+                                "导出结果",
                                 elem_classes="custom-button"
                             )
                         
                         with gr.Row():
                             submit_btn = gr.Button(
-                                "Start Detection",
+                                "开始检测",
                                 variant="primary",
                                 elem_classes="custom-button"
                             )
                             reset_btn = gr.Button(
-                                "Reset Parameters",
+                                "重置参数",
                                 elem_classes="custom-button"
                             )
                 
                 with gr.Column(scale=2):
-                    # Results display
+                    # 结果显示
                     with gr.Tabs():
-                        with gr.TabItem("Detection Results"):
+                        with gr.TabItem("检测结果"):
                             with gr.Row(elem_classes="result-container"):
                                 original_output = gr.Image(
-                                    label="Original Image",
+                                    label="原始图像",
                                     elem_classes="output-image"
                                 )
                                 saliency_output = gr.Image(
-                                    label="Saliency Map",
+                                    label="显著性图",
                                     elem_classes="output-image"
                                 )
                             
                             with gr.Row(elem_classes="result-container"):
                                 heatmap_output = gr.Image(
-                                    label="Heatmap Analysis",
+                                    label="热力图分析",
                                     elem_classes="output-image"
                                 )
                                 overlayed_output = gr.Image(
-                                    label="Overlay Effect",
+                                    label="叠加效果",
                                     elem_classes="output-image"
                                 )
                             
                             with gr.Row(elem_classes="result-container"):
                                 segmented_output = gr.Image(
-                                    label="Object Segmentation",
+                                    label="对象分割",
                                     elem_classes="output-image"
                                 )
                                 comparison_output = gr.Image(
-                                    label="Side-by-Side Comparison",
+                                    label="并排对比",
                                     elem_classes="output-image"
                                 )
                         
-                        with gr.TabItem("Interactive Comparison"):
+                        with gr.TabItem("交互式对比"):
                             with gr.Group(elem_classes="comparison-slider"):
                                 comparison_slider = gr.Slider(
                                     minimum=0,
                                     maximum=1,
                                     value=0.5,
                                     step=0.01,
-                                    label="Original ← → Result",
-                                    info="Drag to compare original and processed images"
+                                    label="原始 ← → 结果",
+                                    info="拖动滑块对比原始图像和处理结果"
                                 )
                                 interactive_comparison = gr.Image(
-                                    label="Interactive Comparison View",
+                                    label="交互式对比视图",
                                     elem_classes="interactive-viz"
                                 )
                         
-                        with gr.TabItem("Analysis Report"):
+                        with gr.TabItem("分析报告"):
                             with gr.Group(elem_classes="result-container"):
                                 time_info = gr.Textbox(
-                                    label="Processing Time",
+                                    label="处理时间",
                                     show_label=True
                                 )
                                 stats_output = gr.HTML(
-                                    label="Statistical Information"
+                                    label="统计信息"
                                 )
                                 analysis_plot = gr.Image(
-                                    label="Detailed Analysis Charts",
+                                    label="详细分析图表",
                                     elem_classes="output-image"
                                 )
 
-        with gr.TabItem("📖 User Guide"):
+        with gr.TabItem("📖 用户指南"):
             gr.Markdown(
                 """
-                ## Instructions
-                1. **Upload Image**: Click the "Input Image" area to upload your image
-                2. **Select Mode**: Choose between "Full Analysis" or "Quick Mode"
-                   - Full Analysis: Complete processing with all visualizations
-                   - Quick Mode: Fast processing, only outputs saliency map
-                3. **Adjust Parameters**: 
-                   - Use threshold slider to adjust detection sensitivity
-                   - Enable contrast enhancement or noise reduction as needed
-                   - Fine-tune brightness, contrast, and filters in advanced settings
-                4. **Start Detection**: Click "Start Detection" to begin analysis
-                5. **View Results**: Check different tabs for various visualization results
-                6. **Export**: Use export options to save your results
+                ## 使用说明
+                1. **上传图像**：点击"输入图像"区域上传您的图像
+                2. **选择模式**：选择"完整分析"或"快速模式"
+                   - 完整分析：完整处理流程，包含所有可视化结果
+                   - 快速模式：快速处理，仅输出显著性图
+                3. **调整参数**： 
+                   - 使用阈值滑块调整检测灵敏度
+                   - 根据需要启用对比���增强或降噪
+                   - 在高级设置中微调亮度、对比度和滤镜
+                4. **开始检测**：点击"开始检测"按钮开始分析
+                5. **查看结果**：在不同标签页查看各种可视化结果
+                6. **导出**：使用导出选项保存您的结果
                 
-                ## Features
-                - **Saliency Map**: Shows importance distribution of image regions
-                - **Heatmap**: Color-coded intensity visualization
-                - **Overlay Effect**: Detection results overlaid on original image
-                - **Object Segmentation**: Extracts key object regions
-                - **Interactive Comparison**: Slide to compare original and processed images
-                - **Analysis Report**: Detailed statistics and analysis charts
+                ## 功能特点
+                - **显著性图**：显示图像区域的显著性分布
+                - **热力图**：彩色编码的强度可视化
+                - **叠加效果**：在原始图像上叠加检测结果
+                - **对象分割**：提取关键对象区域
+                - **交互式对比**：滑动比较原始图像和处理结果
+                - **分析报告**：详细的统计信息和分析图表
                 
-                ## Performance Tips
-                - Use Quick Mode for faster processing when you only need saliency maps
-                - Lower resolution images process faster
-                - Enable GPU if available for better performance
+                ## 性能提示
+                - 当只需要显著性图时使用快速模式
+                - 分辨率较低的图像处理速度更快
+                - 启用GPU可获得更好的性能
                 """
             )
 
-        with gr.TabItem("ℹ️ About"):
+        with gr.TabItem("ℹ️ 关于"):
             gr.Markdown(
                 """
-                ## Project Information
-                - **Version**: 3.0.0
-                - **Architecture**: PyTorch + Gradio
-                - **Model**: CyueNet
-                - **Language**: Multi-language support
+                ## 项目信息
+                - **版本**：3.0.0
+                - **架构**：PyTorch + Gradio
+                - **模型**：CyueNet
+                - **语言**：多语言支持
                 
-                ## Key Features
-                - Real-time image processing and analysis
-                - Multi-dimensional result visualization
-                - Rich image adjustment options
-                - Detailed data analysis reports
-                - Interactive comparison tools
-                - Export functionality
-                - Performance optimization with caching
+                ## 主要特点
+                - 实时图像处理和分析
+                - 多维结果可视化
+                - 丰富的图像调整选项
+                - 详细的数据分析报告
+                - 交互式对比工具
+                - 导出功能
+                - 缓存优化性能
                 
-                ## Update Log
-                - ✅ Added Quick Mode for faster processing
-                - ✅ Enhanced image preprocessing options
-                - ✅ Added statistical analysis functions
-                - ✅ Improved user interface with glassmorphism design
-                - ✅ Added interactive comparison slider
-                - ✅ Performance optimization with caching and threading
-                - ✅ Multi-language chart support
-                - ✅ Export functionality
+                ## 更新日志
+                - ✅ 新增快速模式，提高处理速度
+                - ✅ 增强图像预处理选项
+                - ✅ 新增统计分析功能
+                - ✅ 改进用户界面，采用玻璃拟态设计
+                - ✅ 增加交互式对比滑块
+                - ✅ 使用缓存和线程优化性能
+                - ✅ 多语言图表支持
+                - ✅ 导出功能
                 
-                ## System Requirements
+                ## 系统要求
                 - Python 3.8+
                 - PyTorch 1.9+
-                - CUDA (optional, for GPU acceleration)
-                - 4GB+ RAM recommended
+                - CUDA（可选，用于GPU加速）
+                - 推荐4GB以上内存
                 """
             )
     
-    # Event handlers
+    # 事件处理
     def reset_params():
         return {
             threshold_slider: 50,
             brightness: 0,
             contrast: 0,
-            filter_type: "None",
+            filter_type: "无",
             enhance_contrast: False,
             denoise: False,
             show_contours: True,
-            process_mode: "Full Analysis"
+            process_mode: "完整分析"
         }
     
-    # Set up event handling
+    # 设置事件处理
     submit_btn.click(
         fn=run_demo,
         inputs=[
@@ -767,25 +767,25 @@ with gr.Blocks(title="Advanced Saliency Object Detection System", css=custom_css
         ]
     )
     
-    # Interactive comparison
+    # 交互式对比
     comparison_slider.change(
         fn=create_comparison_view,
         inputs=[original_output, overlayed_output, comparison_slider],
         outputs=[interactive_comparison]
     )
     
-    # Export functionality
+    # 导出功能
     export_btn.click(
         fn=processor.export_results,
         inputs=[export_format],
-        outputs=[gr.Textbox(label="Export Status")]
+        outputs=[gr.Textbox(label="导出状态")]
     )
 
-# Launch the application
+# 启动应用
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=True,
         show_error=True
-    )
+    )