Update app.py

app.py

@@ -390,130 +390,130 @@ class ImageProcessor:
                  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
+        if image is None:
+            return [None] * 9 + ["请提供有效的图像"]
     
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            future_preprocess = executor.submit(preprocess_image)
-            processed_image = future_preprocess.result()
+        # 快速模式检查
+        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)
     
-        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':
-                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()
-        
-        # 存储原始显著性值（未归一化）用于分析
-        original_saliency = res.copy()
-        
-        # 归一化用于可视化
-        res_normalized = (res - res.min()) / (res.max() - res.min() + 1e-8)
-        
-        h, w = original_image.shape[:2]
-        # 调整大小但保持原始值范围
-        res_resized_original = cv2.resize(original_saliency, (w, h))
-        res_resized_normalized = cv2.resize(res_normalized, (w, h))
-        
-        # 生成可视化用的图像
-        res_vis = (res_resized_normalized * 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_original)
-        
-        # 计算统计信息
-        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_original):.2%}",
-            "最大置信度": f"{np.max(res_resized_original):.2%}",
-            "覆盖率": f"{coverage_ratio:.2%}",
-            "处理时间": f"{inference_time:.3f}秒"
-        }
-        
-        # 创建对比图像
-        comparison_img = self.create_comparison_image(original_image, overlayed_rgb)
-        
-        # 保存结果
-        self.last_results = {
-            'saliency_map': res_resized_original,  # 使用原始值
-            'binary_mask': binary_mask,
-            'stats': stats
-        }
+        # 检查完整处理的缓存
+        image_hash = hash(image.tobytes())
+        cache_key = f"{image_hash}_{threshold}_{testsize}_{enhance_contrast}_{denoise}_{brightness}_{contrast}_{filter_type}_full"
         
-        result = (original_image, res_vis, heatmap_rgb, overlayed_rgb, segmented_rgb, 
-                comparison_img, f"处理时间: {inference_time:.4f}秒", stats, analysis_plot)
+        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
         
-        # 缓存结果
-        self.cache[cache_key] = result
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future_preprocess = executor.submit(preprocess_image)
+                processed_image = future_preprocess.result()
         
-        return 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':
+                    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()
+            
+            # 存储原始显著性值（未归一化）用于分析
+            original_saliency = res.copy()
+            
+            # 归一化用于可视化
+            res_normalized = (res - res.min()) / (res.max() - res.min() + 1e-8)
+            
+            h, w = original_image.shape[:2]
+            # 调整大小但保持原始值范围
+            res_resized_original = cv2.resize(original_saliency, (w, h))
+            res_resized_normalized = cv2.resize(res_normalized, (w, h))
+            
+            # 生成可视化用的图像
+            res_vis = (res_resized_normalized * 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_original)
+            
+            # 计算统计信息
+            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_original):.2%}",
+                "最大置信度": f"{np.max(res_resized_original):.2%}",
+                "覆盖率": f"{coverage_ratio:.2%}",
+                "处理时间": f"{inference_time:.3f}秒"
+            }
+            
+            # 创建对比图像
+            comparison_img = self.create_comparison_image(original_image, overlayed_rgb)
+            
+            # 保存结果
+            self.last_results = {
+                'saliency_map': res_resized_original,  # 使用原始值
+                '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):
         """创建对比图像"""