Spaces:
Sleeping
Sleeping
| 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 = """ | |
| :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); | |
| } | |
| .gradio-container { | |
| background: linear-gradient(135deg, var(--background-color), #ffffff); | |
| max-width: 1400px !important; | |
| margin: auto !important; | |
| backdrop-filter: blur(10px); | |
| } | |
| .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); | |
| } | |
| .output-image:hover, .input-image:hover { | |
| transform: scale(1.02) translateY(-2px); | |
| box-shadow: 0 12px 40px 0 rgba(31, 38, 135, 0.5); | |
| } | |
| .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); | |
| } | |
| .custom-button:hover { | |
| transform: translateY(-3px); | |
| box-shadow: 0 12px 30px rgba(33, 150, 243, 0.4); | |
| } | |
| .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); | |
| } | |
| .result-container { | |
| background: var(--glass-bg); | |
| border-radius: 20px; | |
| padding: 20px; | |
| backdrop-filter: blur(15px); | |
| border: 1px solid rgba(255, 255, 255, 0.18); | |
| box-shadow: var(--shadow); | |
| } | |
| .interactive-viz { | |
| border-radius: 15px; | |
| overflow: hidden; | |
| transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1); | |
| box-shadow: var(--shadow); | |
| } | |
| .interactive-viz:hover { | |
| transform: translateY(-5px); | |
| box-shadow: 0 15px 35px rgba(0,0,0,0.15); | |
| } | |
| .statistics-container { | |
| display: grid; | |
| grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); | |
| gap: 15px; | |
| margin-top: 15px; | |
| } | |
| .statistic-card { | |
| background: var(--glass-bg); | |
| padding: 20px; | |
| border-radius: var(--border-radius); | |
| 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; | |
| } | |
| .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); | |
| } | |
| .comparison-slider { | |
| background: var(--glass-bg); | |
| border-radius: 15px; | |
| padding: 20px; | |
| backdrop-filter: blur(10px); | |
| border: 1px solid rgba(255, 255, 255, 0.18); | |
| } | |
| """ | |
| 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("Model loaded successfully") | |
| except RuntimeError as e: | |
| print(f"Model loading error: {e}") | |
| except FileNotFoundError: | |
| print("Model file not found. Please check the path.") | |
| 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 == "Sharpen": | |
| kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]]) | |
| return cv2.filter2D(image, -1, kernel) | |
| elif filter_type == "Blur": | |
| return cv2.GaussianBlur(image, (5,5), 0) | |
| elif filter_type == "Edge Enhancement": | |
| 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.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.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.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.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.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) | |
| 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, "Please provide a valid image" | |
| # Check cache | |
| 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': | |
| with torch.cuda.amp.autocast(): | |
| _, res, *_ = self.model(image_tensor) | |
| else: | |
| with torch.amp.autocast(device_type='cpu'): | |
| _, res, *_ = self.model(image_tensor) | |
| time_end = time.time() | |
| # 确保转换为float32类型 | |
| 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"Quick processing completed in {time_end - time_start:.3f}s") | |
| 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"): | |
| """增强的图像处理函数""" | |
| if image is None: | |
| return [None] * 9 + ["Please provide a valid image"] | |
| # Quick mode check | |
| if process_mode == "Quick 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() | |
| 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() | |
| # 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) | |
| time_start = time.time() | |
| with torch.no_grad(): | |
| if device.type == 'cuda': | |
| 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) | |
| 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) | |
| 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)) | |
| # 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 | |
| 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" | |
| } | |
| # 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, | |
| 'stats': stats | |
| } | |
| result = (original_image, res_vis, heatmap_rgb, overlayed_rgb, segmented_rgb, | |
| comparison_img, f"Processing time: {inference_time:.4f}s", stats, analysis_plot) | |
| # Cache result | |
| 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 | |
| # Add dividing line | |
| 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 "No results to export" | |
| 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" | |
| else: | |
| return f"Results exported as {format_type.lower()} files" | |
| # Create processor instance | |
| 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 + ["Please upload an image"] | |
| # Process image | |
| 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 | |
| # 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) | |
| overlay_with_contours = overlayed.copy() | |
| cv2.drawContours(overlay_with_contours, contours, -1, (0,255,0), 2) | |
| overlayed = overlay_with_contours | |
| # Generate statistics 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>" | |
| 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:] | |
| # 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: | |
| gr.Markdown( | |
| """ | |
| # 🎯 Advanced Saliency Object Detection System | |
| ### AI-Powered Image Saliency Detection and Analysis Tool | |
| """ | |
| ) | |
| with gr.Tabs() as tabs: | |
| with gr.TabItem("🔍 Main Functions"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| # Input controls | |
| with gr.Group(elem_classes="advanced-controls"): | |
| input_image = gr.Image( | |
| label="Input Image", | |
| 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" | |
| ) | |
| with gr.Accordion("Basic Settings", open=True): | |
| threshold_slider = gr.Slider( | |
| minimum=0, | |
| maximum=100, | |
| value=50, | |
| step=1, | |
| label="Detection Threshold", | |
| info="Adjust detection sensitivity" | |
| ) | |
| enhance_contrast = gr.Checkbox( | |
| label="Enhance Contrast", | |
| value=False | |
| ) | |
| denoise = gr.Checkbox( | |
| label="Noise Reduction", | |
| value=False | |
| ) | |
| show_contours = gr.Checkbox( | |
| label="Show Contours", | |
| value=True | |
| ) | |
| with gr.Accordion("Image Adjustments", open=False): | |
| brightness = gr.Slider( | |
| minimum=-100, | |
| maximum=100, | |
| value=0, | |
| step=1, | |
| label="Brightness" | |
| ) | |
| contrast = gr.Slider( | |
| minimum=-100, | |
| maximum=100, | |
| value=0, | |
| step=1, | |
| label="Contrast" | |
| ) | |
| filter_type = gr.Radio( | |
| choices=["None", "Sharpen", "Blur", "Edge Enhancement"], | |
| value="None", | |
| label="Image Filter" | |
| ) | |
| with gr.Accordion("Export Options", open=False): | |
| export_format = gr.Dropdown( | |
| choices=["PNG", "JPEG", "PDF Report"], | |
| value="PNG", | |
| label="Export Format" | |
| ) | |
| 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.Row(elem_classes="result-container"): | |
| original_output = gr.Image( | |
| label="Original Image", | |
| elem_classes="output-image" | |
| ) | |
| saliency_output = gr.Image( | |
| label="Saliency Map", | |
| elem_classes="output-image" | |
| ) | |
| with gr.Row(elem_classes="result-container"): | |
| heatmap_output = gr.Image( | |
| label="Heatmap Analysis", | |
| elem_classes="output-image" | |
| ) | |
| overlayed_output = gr.Image( | |
| label="Overlay Effect", | |
| elem_classes="output-image" | |
| ) | |
| with gr.Row(elem_classes="result-container"): | |
| segmented_output = gr.Image( | |
| label="Object Segmentation", | |
| elem_classes="output-image" | |
| ) | |
| comparison_output = gr.Image( | |
| label="Side-by-Side Comparison", | |
| elem_classes="output-image" | |
| ) | |
| with gr.TabItem("Interactive Comparison"): | |
| 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" | |
| ) | |
| interactive_comparison = gr.Image( | |
| label="Interactive Comparison View", | |
| elem_classes="interactive-viz" | |
| ) | |
| with gr.TabItem("Analysis Report"): | |
| with gr.Group(elem_classes="result-container"): | |
| time_info = gr.Textbox( | |
| label="Processing Time", | |
| show_label=True | |
| ) | |
| stats_output = gr.HTML( | |
| label="Statistical Information" | |
| ) | |
| analysis_plot = gr.Image( | |
| label="Detailed Analysis Charts", | |
| elem_classes="output-image" | |
| ) | |
| with gr.TabItem("📖 User Guide"): | |
| 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 | |
| ## 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 | |
| """ | |
| ) | |
| with gr.TabItem("ℹ️ About"): | |
| gr.Markdown( | |
| """ | |
| ## Project Information | |
| - **Version**: 3.0.0 | |
| - **Architecture**: PyTorch + Gradio | |
| - **Model**: CyueNet | |
| - **Language**: Multi-language support | |
| ## 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 | |
| """ | |
| ) | |
| # Event handlers | |
| def reset_params(): | |
| return { | |
| threshold_slider: 50, | |
| brightness: 0, | |
| contrast: 0, | |
| filter_type: "None", | |
| enhance_contrast: False, | |
| denoise: False, | |
| show_contours: True, | |
| process_mode: "Full Analysis" | |
| } | |
| # Set up event handling | |
| 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 | |
| ] | |
| ) | |
| # 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")] | |
| ) | |
| # Launch the application | |
| if __name__ == "__main__": | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=True, | |
| show_error=True | |
| ) |