HeritageMap Studio
A native Qt6 + OpenGL desktop workstation for cultural-heritage mapping and timeline visualization
A Linux-native desktop application built with C++17, Qt6 Widgets and OpenGL 3.3 for cultural-heritage mapping, metadata exploration and historical timeline visualization. It pairs a self-authored QOpenGLWidget map canvas with a SQLite database, CSV import pipeline, geographic coordinate projection, layer management, timeline playback and faceted search, all organized in a clean layered architecture (model / repository / service / ui).
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 HeritageMap Studio is a Linux-native desktop application built with **C++17 + Qt6 Widgets + OpenGL 3.3**, positioned as a workstation for cultural heritage. It consolidates scattered heritage records into a single window where users can browse spatial distribution, historical era and detailed metadata while exploring interactively. ## Architecture The project follows a clearly layered design: `models` (pure data models such as HeritageSite), `repositories` (data access), `database` (DatabaseManager and a versioned MigrationManager), `services` (CsvReader, ImportService), `utils` (GeoCoordinateTransformer), `opengl` (MapCanvas rendering) and `ui` (MainWindow and dock panels). Responsibilities are strictly separated — models never touch UI or the database, and the rendering layer needs no knowledge of MainWindow internals, wired together purely through Qt signals and slots. ## Rendering & Interaction The central map canvas uses QOpenGLWidget with a hand-written GLSL shader pipeline to render adaptive grids and category-colored sites. It implements a 2D camera, screen-to-world coordinate transforms, mouse pan / wheel zoom and click hit-testing. The GeoCoordinateTransformer projects latitude/longitude into local meter coordinates, with a fallback for records lacking coordinates. ## Data & Filtering The backend uses SQLite with versioned migrations tracked in a schema_migrations table, accessed via the repository pattern. A CSV import pipeline loads heritage sample data (including a Taipei heritage sample). Three unified filter states — layers, timeline and faceted search — jointly drive real-time canvas redraws. ## Progress & Outlook The project has progressed through eight development phases, growing from a bare application shell into a full workstation with database, import, projection, metadata editing, layers, timeline playback and advanced search. Planned next steps include map tile backgrounds, route editing and a more complete GIS projection.
My role
Solo developer (architecture, OpenGL rendering, data layer and UI — full stack)
Problem
Cultural-heritage records typically live scattered across spreadsheets, with no local tool that simultaneously shows spatial distribution, historical era and rich metadata while supporting interactive exploration. General-purpose GIS software is heavyweight and poorly fitted to heritage-specific data models.
Solution
A dockable-panel Qt6 Widgets workstation whose central canvas uses QOpenGLWidget with a hand-written GLSL shader pipeline to draw grids and sites. The backend stores data in SQLite with versioned migrations and exposes it through a repository pattern, while a CSV import service and a geo-coordinate transformer project latitude/longitude into local meter coordinates, then layer, timeline and faceted-search filters drive interactive exploration.
Current outcome
Eight development phases delivered, evolving from an application shell into a working workstation with database, import, projection, metadata editing, layers, timeline and advanced search — built on a cleanly layered architecture ready for map tiles and route editing.
Highlights
- Hand-written OpenGL 3.3 Core Profile shader pipeline rendering adaptive grids and category-colored heritage points, with mouse pan, wheel zoom and click selection
- Versioned SQLite migrations (schema_migrations table) plus a repository pattern fully decoupling data access from UI and rendering
- GeoCoordinateTransformer projects lat/long into local meter coordinates, with fallback handling and a projection summary for sites lacking coordinates
- Clean layered architecture — model / repository / service / ui / opengl / utils — keeping MainWindow from becoming spaghetti
- Three unified filter states for interactive layers, timeline playback and faceted search, all driving canvas redraws
- CMake deliberately isolates the conda toolchain, forcing the system c++ to resolve Qt/OpenGL and avoid environment conflicts
Engineering challenges
- Inside conda environments, Qt6 and desktop OpenGL linking tends to pull in the conda sysroot, requiring CMake to clear CFLAGS/LDFLAGS and pin the system compiler
- Implementing a 2D camera, coordinate transforms and click hit-testing from scratch on raw OpenGL, including screen-to-world projection and adaptive grid spacing
Target users
- Portfolio reviewers and interviewers
- Technical readers who need a quick view of purpose, stack, and maturity
Technical highlights
- Detected technical signals: C++17, Qt6 Widgets, OpenGL 3.3 Core, GLSL Shaders, SQLite, Qt SQL, CMake, QSS, CSV Import
- 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++17, Qt6 Widgets, OpenGL 3.3 Core, GLSL Shaders, SQLite, Qt SQL, CMake, QSS, CSV Import.
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
HeritageMapStudio/ 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
- Add a map tile background layer for geographic context
- Implement route / path editing capabilities
- Introduce formal GIS projection and richer metadata source management