project_overview
live_measurement
spectrum_and_baseline
explainable_agent_trace
video_regions_and_scale
bridge_network
desk_expansion_comparision
human_inspection_review
measured_benchmarks
methods_and_evaluation
system_architecture
vision_measurement_pipeline
condition_decision_logic
durable_work_&_human_approval
cloud_and_mcp_architecture

Inspiration

I wanted to solve a real problem bridge engineers face, the long gaps between physical inspections. Bridges deteriorate silently, and by the time someone notices, the damage might be serious. I thought, what if a simple camera video could give engineers early warning signs between those scheduled visits? That’s where Resonance started, turning everyday video into vibration evidence that actually means something.

What it does

Resonance takes a video of a bridge deck and extracts its vibration signature. It measures the dominant frequency, tracks how it changes over time, and compares it against a healthy baseline. If the frequency drops, which can signal stiffness loss, it flags it for an engineer to review. There’s a full console with charts, spectrum plots, an agent trace showing every decision, and a human-gated approval flow so no inspection request goes out without a real person signing off.

How we built it

The engine is Python with OpenCV 5 doing the heavy lifting : phase correlation and Riesz local phase for sub-pixel motion extraction, ALIKED and LightGlue for camera shake stabilization. Signal processing uses SciPy for Welch spectra and bootstrap uncertainty intervals. The API is FastAPI with a separate durable worker and SQLite for local persistence. The frontend is React with real-time WebSocket updates. For cloud, we used AWS CDK with a COOL Graviton instance behind CloudFront, S3, SQS, DynamoDB and SNS for notifications.

Challenges we ran into

Amplitude accuracy was the biggest headache... frequency recovery hit our targets on synthetic inputs, but amplitude kept missing. We had to be honest about that instead of fudging it. Another tricky one was discovering that OpenCV’s native ALIKED wrapper silently ignores the mask argument, so we had to build our own keypoint filtering to keep deck motion from being subtracted as camera shake. Getting reliable timing from phone slow-motion video was also harder than expected where playback metadata lies, so we had to build in strict acquisition-rate verification.

Accomplishments that we're proud of

The agent trace is something I’m really happy with... every single decision is recorded and explainable. No black box. The failure cases are equally important: the system correctly refuses to give a reading when texture is bad, lighting is poor, or the frame rate can’t support the frequency band. We didn’t hide those edge cases; we made them a feature. And the human-in-the-loop approval flow means the system can never send an inspection notification on its own.

What we learned

Honesty in measurement is harder than measurement itself. It’s tempting to report a number and move on, but the uncertainty interval, the limitations, the things you can’t measure, that’s where the real engineering lives. We also learned that synthetic evaluation gets you started but never finishes the job. Real desk recordings with accelerometers taught us things that generated sine waves never could.

What's next for Resonance

We want to expand the camera watch system for continuous monitoring... multiple bridges, multiple cameras, all feeding into the same evidence pipeline. Better amplitude estimation is on the roadmap, potentially with calibrated reference targets. And we’re exploring VLM integration for richer scene understanding, imagine the system recognising not just that a truck crossed, but understanding the broader structural context from the video itself.