FireWatch

Detection of fire in image
Website
Drone in operation
Coding
Wokspace
More coding

Inspiration

Wildfires can grow from a small ignition into a much larger emergency in a short period of time. That made us think about two problems: How can a fire be detected as early as possible, and how can a response begin without putting a person directly in harm's way?

That question inspired FireWatch, a prototype system that combines aerial monitoring, computer vision, a ground response unit, and a central command dashboard. Rather than treating fire detection and response as separate problems, we wanted to explore what a connected system could look like from initial detection all the way through response and verification.

What it does

FireWatch uses a camera-equipped drone as the system's eyes. A YOLOv8 computer-vision model analyzes the video feed for signs of fire. To reduce the chance of reacting to a single incorrect detection, FireWatch requires fire to be detected across multiple consecutive frames before confirming an incident.

Once a fire is confirmed, the detector communicates with our FireWatch backend and the web dashboard automatically creates an active incident. From there, a ground response unit can be dispatched toward the detected area.

The dashboard follows the response through several stages:

Fire Detected → Fire Confirmed → Ground Unit Dispatched → Unit Arrived → Suppression → Drone Verification → Contained / Escalation

The ground vehicle is designed to serve as the physical response platform, while the drone remains the aerial observer. After a suppression attempt, the drone can continue monitoring the area. In our prototype verification logic, the system looks for multiple consecutive frames without a fire detection before changing the incident state rather than relying on a single frame.

The FireWatch dashboard acts as the command center, displaying the active incident, drone status, ground-unit status, detection confidence, environmental information, and a chronological event log.

How we built it

For fire detection, we integrated a YOLOv8 fire-and-smoke detection model trained on the D-Fire dataset. We first tested the model independently and then connected it to a live camera feed using Python and OpenCV.

Our live detection pipeline uses:

Python for the detection and system logic
Ultralytics YOLOv8 for computer vision
OpenCV for live video processing
Flask for the local FireWatch backend/API
HTML, CSS, and JavaScript for the command dashboard
HTTP/JSON requests for communication between the detector, server, and dashboard

Instead of allowing one detection to trigger the entire system, we created a confirmation mechanism that requires several consecutive fire-positive frames. Once confirmed, the Python detector sends the incident information—including its confidence and source—to our Flask server.

The dashboard continuously communicates with the backend and updates when an incident occurs. We then built a state-based ground response workflow so an operator can report when the vehicle arrives and begins suppression. That event tells the backend to enter verification mode, allowing the aerial detection system to evaluate whether fire is still being detected.

We designed the software so that individual components can later be replaced without rebuilding the entire system. For example, during development we can use a computer webcam as the video source, while the final architecture can use the drone's Wi-Fi camera stream.

Challenges we faced

One of our biggest challenges was turning several individual components into one connected system. Detecting a fire with AI was only the beginning. We needed the detection model to communicate with a server, the server to communicate with a dashboard, and the dashboard to represent what the physical system was doing.

False or inconsistent detections were another challenge. Computer vision can briefly lose sight of an object or incorrectly classify a frame, so we did not want FireWatch to make decisions based on one image. We implemented consecutive-frame confirmation for both initial detection and our prototype post-suppression verification.

We also had to continuously refine the architecture as we built. For example, rather than adding another camera to the ground vehicle, we realized the drone could remain the system's aerial observer while the car focused on physical response. That reduced unnecessary hardware and gave each component a clearer role.

And, like any rapidly built prototype, we encountered plenty of debugging challenges—from API communication to Python indentation errors—but each one forced us to better understand how the individual parts of the system interact.

What we learned

The biggest lesson from FireWatch was that building an intelligent system is about much more than getting an AI model to work.

We learned how to take a computer-vision model and integrate it into a larger application, process live video with OpenCV, create communication between Python and a Flask API, synchronize a web interface with backend state, and design a workflow connecting software with physical hardware.

We also learned the importance of designing around uncertainty. A detection model is not perfect, so our system needed confirmation states, verification logic, and clear distinctions between what the prototype can demonstrate and what a real emergency-response system would require.

What's next for FireWatch

Our next goal is to expand the command dashboard with a live patrol map showing the base station, drone, ground response unit, detected incident, and response route. During development, this can use simulated coordinates before being connected to real GPS data.

We also want to integrate the drone's actual Wi-Fi camera stream, connect more of the ground vehicle's controls to the software, improve fire verification, and develop an escalation workflow for incidents that remain active after an attempted response.

Long term, FireWatch could explore additional environmental sensors, autonomous patrol routes, GPS-based incident mapping, improved fire-severity analysis, and integration with appropriate emergency-response infrastructure.

FireWatch is currently a prototype, not a replacement for professional wildfire detection or emergency-response systems. But the project demonstrates our core idea: combine early aerial detection, intelligent software, and rapid ground response into one coordinated system designed to react before a small fire has the opportunity to become a much larger one.