GeoVideo Evidence Viewer
C++/Qt6 desktop tool for video event retrieval and spatial visualization
A desktop application built in C++20 and Qt6 for reviewing surveillance footage, indexing motion-related events, configuring spatial regions of interest (ROIs), and visualizing incidents on a field map. It follows a clean layered architecture (domain / application / infrastructure / UI) and already ships transactional SQLite schema migration, repositories, dependency-injected services, and OpenCV video metadata extraction; playback, ROI editing, and motion detection pipelines are still in progress.
Verified Demo Recording 1
Copied by the portfolio quality pass from existing project demo media.
Media overview
Browse the project screenshots and recorded walkthroughs.
Project links and demo readiness
live
Live Demo
Open the verified live demo when available, or use the internal run guide for manual demo preparation.
github
View GitHub
Open the public repository when available, or review the source-access status captured by this case study.
video
Demo Recording
Open the demo recording when available, or use this section as the recording checklist for the project.
documentation
README
Open the project README when available, or use this case study as the documentation baseline.
Project overview
## Overview GeoVideo Evidence Viewer is a **C++20 / Qt6** desktop application positioned as a portfolio-grade video evidence tool for smart-city, campus-safety, facility-monitoring, traffic-technology, and security-review workflows. It lets users review surveillance footage locally, index motion-related events, configure spatial regions of interest (ROIs), and visualize incidents on a 2D/3D field map. ## Architecture The project uses a clean layered architecture split into four layers: `core/domain` (domain models such as Project, Camera, VideoSource, Roi, and Event, plus value objects EntityId/TimeRange/Severity), `application/services` (application services and a ServiceResult type), `infrastructure` (SQLite connection, SchemaMigrator, and sqlite repositories), and `app` (the Qt6 main window and dock-panel widgets). An `AppContext` acts as the composition root, initializing the database and injecting repositories and services. ## Data and Video Layer Data is stored in embedded **SQLite**, where `SchemaMigrator` runs versioned migrations inside an IMMEDIATE transaction, creating projects, cameras, video_sources, rois, and events tables with cascading foreign keys and multiple query indexes (time range, type, review status, and more). The video layer uses **OpenCV** VideoCapture to extract resolution, FPS, and frame count, defensively converting NaN and non-positive values. ## UI and Engineering The interface is a Qt6 Widgets dock-based workspace with a central video viewer surrounded by project explorer, event detail, event timeline, event search, and an OpenGL spatial view, supporting nested/tabbed docking and layout memory. The build uses **CMake + Ninja** with AUTOMOC/AUTORCC/AUTOUIC, compile-commands export, and cross-platform targets for Linux, Windows, and macOS. ## Status The data layer and application skeleton are runnable: creating projects, importing videos (extracting metadata and persisting to SQLite), and saving/restoring layout all work today. Real video playback, the ROI editor, the motion-detection pipeline, evidence export, and report generation are the next milestones.
My role
Solo developer (architecture and full desktop implementation)
Problem
Smart-city, campus-safety, and facility-monitoring teams need a tool to review large volumes of surveillance video locally, annotate regions of interest, search and triage events, and produce case reports, but most options are cloud-locked, hard to customize, or lack spatial visualization.
Solution
A Qt6 Widgets dock-based workspace with a central video viewer surrounded by project explorer, event detail, event timeline, search, and a 2D/3D OpenGL spatial view. The backend uses an embedded SQLite database for projects, cameras, video sources, ROIs, and events, with a transactional SchemaMigrator for versioned migrations and an AppContext composition root that injects repositories and services; OpenCV handles video metadata extraction.
Current outcome
Delivered a runnable desktop skeleton plus a working data layer: the Qt6 UI shell, a versioned SQLite schema (projects/cameras/video_sources/rois/events with indexes and foreign keys), SQLite repositories, ProjectService/VideoImportService/EventReviewService, OpenCV-based video parsing, and persisted window/dock layout.
Highlights
- Clean layered architecture separating domain, application, infrastructure, and UI, decoupling domain models from the Qt UI
- Versioned SQLite schema migration run inside an IMMEDIATE transaction for atomic table creation, with full foreign keys and query indexes
- Centralized dependency injection via AppContext wiring database, repositories, and application services
- OpenCV VideoCapture extracts resolution/FPS/frame count with defensive handling of NaN and non-positive values
- Qt6 dock workspace with nested/tabbed docking and layout persistence restored via QSettings
- CMake + Ninja with AUTOMOC and CONFIGURE_DEPENDS source globbing, targeting Linux, Windows, and macOS
Engineering challenges
- Applying domain-driven layering in a C++/Qt desktop context without coupling UI to data access
- Designing an evolvable SQLite schema with transactional migrations that balance foreign-key integrity and query performance
- Robustly reading multi-format video metadata via OpenCV while guarding against invalid property values
Target users
- Portfolio reviewers and interviewers
- Technical readers who need a quick view of purpose, stack, and maturity
Technical highlights
- Detected technical signals: C++20, Qt6, Qt6 Widgets, Qt6 Multimedia, Qt6 OpenGLWidgets, OpenCV, SQLite, CMake, Ninja, clangd
- README evidence exists and can support a fuller reviewed case study
- A public GitHub repository is not verified yet; the portfolio marks it as pending
Architecture
This case study is generated from the portfolio catalog pipeline using README, Git metadata, package/build configuration, and media signals. The final architecture narrative still needs source-level review. Current detected technology signals include: C++20, Qt6, Qt6 Widgets, Qt6 Multimedia, Qt6 OpenGLWidgets, OpenCV, SQLite, CMake, Ninja, clangd.
Data flow
A public data-flow narrative is not fully reviewed yet. If the project includes data processing, AI pipelines, or backend APIs, the next pass should document input, processing, storage, and UI/output flow end to end.
Project structure
geovideo-env-check/ README.md # project documentation, when available source files # implementation reviewed by local audit package/build config # detected capability signals
Setup / Run guide
This project does not expose a verified runnable web command yet. Review the README/source tree and add exact install, run, test, and build commands before interview use. No verified build command was detected. Treat the current portfolio page as a case-study placeholder until build steps are reviewed.
Future improvements
- Complete the production-quality README, screenshots, and demo recording
- Add architecture diagrams, data-flow notes, and key technical decisions
- Verify build/test status and update the portfolio release report
Interview notes
- State the current maturity and demonstrable scope first
- Focus on verified stack, source structure, and completed behavior
- Do not claim unverified deployment, video, or test coverage as finished
Next steps
- Wire up real video playback, frame stepping, and timeline navigation
- Implement the ROI editor and an OpenCV motion-detection pipeline that persists events to the database
- Add snapshot/clip export, case report generation, and 2D/3D spatial visualization