并行发送隐患识别请求并确认返回最多的场景

shudao-vue-frontend/src/views/HazardDetection.vue

@@ -1302,52 +1302,80 @@ const getAutoSceneCandidates = (preferredScene = "") =>
     getCandidateSceneOrder(preferredScene);
 
 const detectSceneAutomatically = async (baseRequestData) => {
-    let lastErrorMessage = "";
-
-    for (const sceneKey of getAutoSceneCandidates(baseRequestData.scene_name)) {
-        try {
-            const response = await apis.hazardDetection({
-                ...baseRequestData,
-                scene_name: sceneKey,
-            });
-            const isSuccess =
-                response.code === 200 || response.statusCode === 200;
-
-            if (isSuccess) {
-                const backendData = response.data || {};
-                const hasDetections =
-                    Array.isArray(backendData.detections) &&
-                    backendData.detections.length > 0;
-                const hasLabels =
-                    (Array.isArray(backendData.labels) &&
-                        backendData.labels.length > 0) ||
-                    (Array.isArray(backendData.display_labels) &&
-                        backendData.display_labels.length > 0) ||
-                    (Array.isArray(backendData.third_scenes) &&
-                        backendData.third_scenes.length > 0);
-
-                if (hasDetections || hasLabels) {
-                    return {
-                        response,
-                        sceneKey,
-                    };
-                }
+    const sceneCandidates = getAutoSceneCandidates(baseRequestData.scene_name);
+    
+    // 并行发送所有场景请求
+    const requests = sceneCandidates.map(sceneKey => 
+        apis.hazardDetection({
+            ...baseRequestData,
+            scene_name: sceneKey,
+        })
+        .then(response => ({
+            sceneKey,
+            response,
+            success: response.code === 200 || response.statusCode === 200
+        }))
+        .catch(error => ({
+            sceneKey,
+            response: null,
+            success: false,
+            error: error?.msg || error?.message || "请求失败"
+        }))
+    );
 
-                lastErrorMessage =
-                    response.msg || response.message || lastErrorMessage;
-            } else {
-                lastErrorMessage =
-                    response.msg || response.message || lastErrorMessage;
-            }
-        } catch (error) {
-            lastErrorMessage =
-                error?.msg || error?.message || lastErrorMessage;
-        }
+    // 等待所有请求完成
+    const results = await Promise.all(requests);
+
+    // 计算每个成功响应的检测数量
+    const validResults = results
+        .filter(result => result.success && result.response?.data)
+        .map(result => {
+            const backendData = result.response.data || {};
+            const detectionCount = (Array.isArray(backendData.detections) ? backendData.detections.length : 0);
+            const labelCount = (Array.isArray(backendData.labels) ? backendData.labels.length : 0) +
+                             (Array.isArray(backendData.display_labels) ? backendData.display_labels.length : 0);
+            const hazardCount = (Array.isArray(backendData.third_scenes) ? backendData.third_scenes.length : 0);
+            
+            return {
+                ...result,
+                totalCount: detectionCount + labelCount + hazardCount,
+                detectionCount,
+                labelCount,
+                hazardCount
+            };
+        })
+        .filter(result => result.totalCount > 0); // 只保留有检测结果的
+
+    // 如果有有效结果,选择检测数量最多的
+    if (validResults.length > 0) {
+        // 按总检测数量降序排序
+        validResults.sort((a, b) => b.totalCount - a.totalCount);
+        const bestResult = validResults[0];
+        
+        console.log('[并行检测] 所有结果:', validResults.map(r => ({
+            scene: r.sceneKey,
+            total: r.totalCount,
+            detections: r.detectionCount,
+            labels: r.labelCount,
+            hazards: r.hazardCount
+        })));
+        console.log('[并行检测] 选择场景:', bestResult.sceneKey, '检测数量:', bestResult.totalCount);
+        
+        return {
+            response: bestResult.response,
+            sceneKey: bestResult.sceneKey,
+        };
     }
 
-    throw new Error(
-        lastErrorMessage || "暂未识别到支持的场景，请尝试更换更清晰的图片"
-    );
+    // 如果没有有效结果,收集错误信息
+    const errorMessages = results
+        .filter(r => !r.success || !r.response?.data)
+        .map(r => r.error || r.response?.msg || r.response?.message)
+        .filter(Boolean);
+    
+    const lastErrorMessage = errorMessages[errorMessages.length - 1] || "暂未识别到支持的场景,请尝试更换更清晰的图片";
+    
+    throw new Error(lastErrorMessage);
 };
 
 const updateElementOverlayPosition = async () => {