4 video sources- fire detection

app.py

@@ -57,7 +57,7 @@ def analyze_fire_scene(frame):
         inputs = inputs.to(device)
         
         with torch.no_grad():
-            outputs = vqa_model.generate(**inputs, max_new_tokens=20, do_sample=False)  # Shorter responses
+            outputs = vqa_model.generate(**inputs, max_new_tokens=10, do_sample=False, num_beams=1)  # Faster generation
         
         answer = vqa_processor.decode(outputs[0], skip_special_tokens=True)
         answer = answer.split("Assistant:")[-1].strip() if "Assistant:" in answer else answer
@@ -207,6 +207,33 @@ def respond(
 """
 For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
 """
+def detect_fire_api(image_data):
+    """API endpoint for fire detection"""
+    import base64
+    from PIL import Image
+    import io
+    
+    try:
+        # Decode base64 image
+        img_bytes = base64.b64decode(image_data)
+        image = Image.open(io.BytesIO(img_bytes))
+        # Keep image small for faster processing
+        if image.size[0] > 320:
+            image = image.resize((320, 240))
+        frame = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        
+        # Analyze frame
+        fire_detected, smoke_detected, fire_details = analyze_fire_scene(frame)
+        
+        return {
+            "fire_detected": fire_detected,
+            "smoke_detected": smoke_detected,
+            "details": fire_details,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
 demo = gr.ChatInterface(
     respond,
     additional_inputs=[
@@ -225,4 +252,17 @@ demo = gr.ChatInterface(
 
 
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    # Add API endpoint
+    from fastapi import FastAPI
+    import uvicorn
+    
+    app = FastAPI()
+    
+    @app.post("/detect_fire")
+    async def api_detect_fire(request: dict):
+        return detect_fire_api(request["image"])
+    
+    # Mount Gradio app
+    demo_app = gr.mount_gradio_app(app, demo, path="/")
+    
+    uvicorn.run(app, host="0.0.0.0", port=7860)

mcp_client.py

@@ -24,16 +24,19 @@ class FireDetectionClient:
             # Convert frame to PIL Image
             image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
             
+            # Resize image to reduce processing time
+            image = image.resize((320, 240))  # Smaller size for faster processing
+            
             # Convert to base64
             buffer = io.BytesIO()
-            image.save(buffer, format='JPEG')
+            image.save(buffer, format='JPEG', quality=70)  # Lower quality for speed
             img_str = base64.b64encode(buffer.getvalue()).decode()
             
-            # Send to MCP server (assuming it has an API endpoint)
+            # Send to MCP server API endpoint with longer timeout
             response = requests.post(
                 f"{self.mcp_server_url}/detect_fire",
                 json={"image": img_str},
-                timeout=5
+                timeout=30  # Increased timeout
             )
             
             if response.status_code == 200:
@@ -60,13 +63,27 @@ class FireDetectionClient:
                 
             frame_count += 1
             
-            # Process every 100th frame
-            if frame_count % 100 == 0:
+            # Process every 200th frame (less frequent for stability)
+            if frame_count % 200 == 0:
                 timestamp = datetime.now().strftime("%H:%M:%S")
                 print(f"[{timestamp}] Source {source_id}: Analyzing frame {frame_count}")
                 
-                # Simple fire detection (replace with MCP call)
-                fire_detected, smoke_detected = self.simple_fire_detection(frame)
+                try:
+                    # Use MCP server for fire detection
+                    result = self.detect_fire_mcp(frame)
+                    
+                    if "error" in result:
+                        print(f"MCP Error: {result['error']}")
+                        # Fallback to simple detection
+                        fire_detected, smoke_detected = self.simple_fire_detection(frame)
+                    else:
+                        fire_detected = result.get("fire_detected", False)
+                        smoke_detected = result.get("smoke_detected", False)
+                        
+                except Exception as e:
+                    print(f"Connection error: {e}")
+                    # Use fallback detection
+                    fire_detected, smoke_detected = self.simple_fire_detection(frame)
                 
                 if fire_detected or smoke_detected:
                     alert = f"🚨 ALERT - Source {source_id} at {timestamp}:\n"
@@ -79,7 +96,7 @@ class FireDetectionClient:
                     print(alert)
                     # Here you could send notifications, save alerts, etc.
             
-            time.sleep(0.01)  # Small delay to prevent CPU overload
+            time.sleep(0.03)  # Longer delay to reduce load
         
         cap.release()
         print(f"Stopped monitoring source {source_id}")

pyproject.toml

@@ -18,5 +18,8 @@ dependencies = [
     "opencv-python",
     "torch>=2.7.1",
     "accelerate>=1.10.0",
+    "fastapi",
+    "uvicorn",
+    "requests"
 ]