FINDS - TESTS · Slate 3, Test 7 — Maps/3D Trio for Pischana
Date: 2026-11-20 · Test folder: ~/workspace/finds-tests/maps-trio-2026-11-20/
Subjects: A — blosm (#6) · B — threejs-procedural-building-generator (#9) · C — Meshroom (#10), each with its own verdict.
Environment: this VM — 1.5 shared CPUs (throttled), ~6 GB usable RAM, no GPU, Ubuntu 24.04, Python 3.12.3, Node 24.22.1. Subjects run strictly one at a time. All work read-only against Ros's live projects.
Context: Pischana = Ros's planned web 3D recreation of the village of Піщана, Ukraine (Vite/TypeScript/three.js, OSM data, elevation models). Gemini Deep Research (2026-11-18) recommended a "Data-First OSM Typology" route. deck.gl was Adopted in slate 2.2 as the default data-first web-map stack. These three finds are candidate pieces of that pipeline.
Up-front limitation (affects Subject A): Ros's files nowhere identify which Піщана. An exhaustive hunt —
~/workspace/pischana/(empty), the MY - PISCHANA chat read in full, memory files, the Gemini research doc and its prompts, the Odesa prototype brief — contains no oblast, district, coordinates, or nearby town, and there are dozens of villages named Піщана in Ukraine. Per the brief (never guess a same-named village), Subject A ran on a clearly-labelled proxy: Khotiv village, Kyiv Oblast (bbox 30.455–30.475 E, 50.319–50.339 N), a real OSM village extract of similar character (low-rise, pitched roofs, a lake, forest edge). All fidelity numbers describe the blosm pipeline, not Ros's village. The moment Ros names his Піщана's coordinates, the same pipeline re-runs in minutes.
Subject A — blosm (#6, vvoovv/blosm)
Provenance / upkeep
- Blender addon (GPL) that imports OpenStreetMap data and terrain into Blender. The GitHub repo's default branch is README-only — the addon is distributed via Gumroad; the full GPL source lives on the repo's
releasebranch: blosm v2.8.1, branch HEAD committed 2026-11-18 (two days before this test). Actively maintained. - Host: Blender 4.2.3 LTS (official tarball, installed into the test folder, runs headless fine).
What ran
- Fetched a complete OSM extract for the proxy bbox via the OSM API 0.6 map endpoint (Overpass was capacity-limited; the API extract has 0 missing node refs). Saved as
blosm/proxy-village.osm; ground truth counted independently (blosm/ground-truth.json). - Imported it with blosm through the addon's real GUI operator (
bpy.ops.blosm.import_data), headless: mode 3D simple, buildings + highways + water + forests + vegetation on, one deliberate deviation from GUI defaults — default roof shape gabled instead of flat (the extract carries zeroroof:shapetags; gabled is the one-click choice a village import would use). - Imported SRTM terrain (tile N50E030) and re-ran in blosm's documented order — terrain first, then OSM — to test draping.
- Exported glTF (GLB) as the bridge format toward three.js/deck.gl, saved .blend files, and rendered three Cycles CPU stills (
blosm/out/render-aerial.png,render-closeup.png,render-terrain.png).
Evidence — import fidelity vs the OSM source
| Layer | In source | In Blender | Transfer |
|---|---|---|---|
| Buildings | 1,734 ways | 1,734 (blosm log count), one joined mesh, 20,166 verts / 11,818 polys, wall/roof/grey materials | 100% |
| Highways | 227 ways, 9 classes | 227 curve splines in 7 class objects + 7 cross-section profiles | 100% (classes merged sensibly: residential 93 = 90 residential + 3 living_street; footway 45 = 23 footway + 22 path; service 57, tertiary 7, track 17, unclassified 5, steps 3 — all exact) |
| Water | 12 polys | 12 polys | 100% |
| Forest (natural=wood) | 11 polys | 11 polys | 100% |
| Vegetation/landuse | 80 landuse polys | 14 polys in the vegetation mesh (subset classes) | partial by design |
- Heights come from the data: 1,163 of 1,734 buildings carry
building:levels(level height 3.0 m, the GUI default); the rest get blosm's per-type defaults. The close-up render shows exactly the target character — individual gabled houses with varied real footprints (including L-shaped plans), a road network, the lake, forest edge. - Terrain: SRTM mesh 5,550 verts / 5,402 polys, 68 m of relief across the tile. Terrain-first order → buildings drape onto the relief (building vertices span z 2.0–85.2 m). Terrain-after order → the flat-imported village is buried under the hillside (kept as evidence in
render-terrain.png): import order is a real workflow rule, not a detail. - glTF bridge: GLB export works (1,467,980 bytes, meshes + materials). Caveat: roads import as Blender curves, and curves export to glTF as empty meshes (exporter warnings confirm) — the GLB carries buildings/water/forest but not road geometry. Feeding roads to the web scene means converting curves to meshes in Blender first, or re-deriving roads from OSM in the web stack (which the typology route does anyway).
- End-to-end wall time once set up: seconds for the import itself; under a minute including stats, GLB export and a Cycles still, on this throttled VM.
Effort / friction (upkeep evidence)
- The addon's documented command-line path (
script/command_line.py) is stale and broken in v2.8.1 — five separate defects hit in sequence (package import naming, renderer scene-property access, argv handling, a strictparseArgs()that kills the run, and a stack of GUI-only app attributes —levelHeight,singleObject, the layer classes — that the CLI app never defines). The maintained path is the GUI operator; driven headless with scene properties set, it worked first try. A GUI user would never see any of this; a pipeline scripter will. - Two more headless gotchas, both diagnosed and fixed: Blender's Allow Online Access preference gates the terrain download, and the OSM-file import does not update the panel extent properties — they keep the factory default (a slice of Manhattan, 40.746 N / 73.989 W), so a naive headless terrain import downloads the New York SRTM tile. Setting the four extent props to the target bbox fixes it. The SRTM download itself repeatedly died mid-stream from inside Blender (IncompleteRead); fetching the tile with curl-resume into blosm's cache dir worked.
- Install effort: Blender tarball + addon from the release branch ≈ 15 minutes; the CLI debugging was the long tail (~half the subject's time). All of it is one-time setup knowledge, captured in
blosm/driver2.py/driver5.py.
Limits
- Proxy data (see up-front note) — fidelity is proven for the pipeline, not for Ros's village.
- 3D-simple mode = flat colours, no textures/facades. The character comes from footprints, levels and roof shapes — which for a village is most of the character. (The textured "3D realistic" mode needs asset packages and is a different, heavier product tier.)
- No GPU here is irrelevant for blosm itself (import is CPU-light); Cycles stills were kept small (1100×800, 24–32 samples).
Verdict — Adopt (scoped)
Adopt blosm as the Pischana pipeline's offline geometry baker and reference: OSM extract → terrain + draped village → GLB, and as the ground-truth render the hand-rolled three.js typology output gets compared against. It is not the runtime — the web scene still ships via three.js/deck.gl — it is the fastest proven way to turn the village's OSM data into correct 3D, and it de-risks the typology work (roof rules, level defaults, class merges are all visible in its output).
Draft test record — Subject A
- Find: #6 — blosm (vvoovv/blosm)
- What ran: Blender 4.2.3 LTS + blosm v2.8.1 (release branch) headless; OSM import (3D simple, gabled default roofs) of a complete village extract on proxy data (Khotiv, Kyiv Oblast — Ros's Піщана is not identified in his files); SRTM terrain import + terrain-first draped re-import; GLB export; 3 Cycles stills.
- When: 2026-11-20
- Outcome: Ran fully. 100% feature transfer (1,734/1,734 buildings, 227/227 highway ways, 12/12 water, 11/11 forest); terrain draping verified (68 m relief); GLB bridge works for meshes, roads excluded (Blender curves). Addon's CLI path is broken in v2.8.1; GUI operator path works headless.
- Output:
~/workspace/finds-tests/maps-trio-2026-11-20/blosm/out/(render-aerial.png, render-closeup.png, render-terrain.png, blosm-import.glb, .blend files, blosm-stats.json) +ground-truth.json, drivers inblosm/. - Reuse proposal: Adopt — scoped to the Pischana pipeline as offline OSM→3D baker/reference with GLB export into the web scene.
Subject B — threejs-procedural-building-generator (#9, Aljullu/threejs-procedural-building-generator)
Provenance / upkeep
- A 2012–2013 CS thesis project (Albert Juhé Lluveras) that procedurally generates urban buildings in the browser: parametric floor shapes, texture atlases, and Collada (.dae) window/balcony/roof models. Last commit 2019-05-20 (8850b8f, "Add LICENSE") — unmaintained for 6½ years. Ships its own bundled pre-module three.js (r50s-era API:
THREE.Geometry,MeshFaceMaterial— both long removed from modern three.js).
What ran
- Built one parametric street with the tool's own API (
new Building(parameters), the same call shape its editor uses): 18 buildings in two rows along a road strip (procedural-buildings/repo/street.html— one added file in the repo copy; the repo itself otherwise untouched), parameters set by hand per building: footprint 32–58 × 24–36, height 14–30 (1–4 floors), floorHeight 6.5–7.6, windowsSeparation 3.8–5.5, probabilityNextFloorDifferentShape 0–0.35, 6 different wall textures and 3 roof textures from the repo's own sets, windowsGroup pairs/normal, windowRepetition lineal/random. - Served locally and screenshot with Playwright (chromium headless shell 1255, SwiftShader WebGL): aerial, street-level, and facade views (
street-aerial.png,street-street.png,street-facade.png). All 18 building meshes built; zero console/page errors; ~11k vertices for the whole street.
Evidence
- Parameter control is real: heights, footprints, floor-shape changes, window density/rhythm and facade textures all respond as set — the two rows read as varied-but-related blocks, and the street-level shot is a coherent little street.
- Character is wrong for Pischana, structurally: the generator's vocabulary is urban Mediterranean apartment blocks — flat roofs with parapets only (the roof model is a slab + parapet wall proportion + roof objects; there is no pitched-roof parameter anywhere in the API), brick facades, balconies with awnings, rooftop billboards. A Ukrainian village of gabled khata houses is outside what it can express — the same test that made blosm's gabled output read instantly as "village" makes this read instantly as "Barcelona block".
- Age shows in the output: the .dae attachments (awnings, balconies, billboards, roof elements) render as pure black silhouettes in a current browser — their textures never reach the materials through the bundled ColladaLoader path. Fixing that is archaeology, not configuration.
- Integration cost into Vite/TS/three.js: high. The code is global-script, pre-module, and depends on three.js APIs removed years ago (
THREE.Geometry,THREE.MeshFaceMaterial). It cannot import alongside a modern three.js; using it means either an isolated iframe running its bundled 2013 three.js forever, or a rewrite of the geometry core — at which point the hand-rolled typology approach (already Ros's direction in sausalito-3d) is strictly less work for a better-fitting result.
Effort
- ~1 hour total: API read from source, one HTML file, screenshot harness. No build tooling exists to fight — the cost isn't setup, it's the dead-end architecture.
Limits
- Judged at village scale by design (the brief's question); it would score better as a city-block filler, which is not Pischana's need.
Verdict — Skip (for the Pischana pipeline)
The one thing it might have offered — cheap parametric variety — is delivered better by the hand-rolled typology route, which can do pitched roofs, real OSM footprints, and modern three.js. Nothing here is worth porting.
Draft test record — Subject B
- Find: #9 — threejs-procedural-building-generator (Aljullu/threejs-procedural-building-generator)
- What ran: Built an 18-building parametric street with the tool's own
Building(parameters)API (varied footprint/height/floor/window/texture params), rendered in-page and screenshot via Playwright headless Chromium (aerial/street/facade). - When: 2026-11-20
- Outcome: Ran cleanly (18/18 meshes, 0 page errors), parameter control confirmed — but output character is flat-roofed urban blocks; pitched roofs are inexpressible; .dae attachments render black in modern browsers; code is pre-module three.js with removed APIs (last commit 2019-05-20).
- Output:
~/workspace/finds-tests/maps-trio-2026-11-20/procedural-buildings/street-aerial.png,street-street.png,street-facade.png, page atprocedural-buildings/repo/street.html. - Reuse proposal: Skip — scoped to the Pischana pipeline; the hand-rolled OSM typology route supersedes it.
Subject C — Meshroom (#10, alicevision/Meshroom)
Provenance / upkeep
- AliceVision's open-source (MPL-2.0) node-based photogrammetry framework: photo set in → textured 3D mesh out. Actively maintained: latest stable 2025.1.0 (August 2025), built on AliceVision 3.3.0, with development continuing (plugin architecture, Gaussian-splatting and segmentation extensions via MeshroomHub).
What ran — NOT RUN, two independent blockers
Blocker 1 — no usable photo set of Ros's exists in reachable storage. The test's point is his photos → a model for his maps, so stock photos were not substituted. The hunt:
- ~/workspace/user/media_library/ — empty (0 files); uploaded media library — 0 photos.
- ~/workspace/user/files/ — 168 chat-attachment photos; the only GPS-clustered group (8 photos at one location) was contact-sheeted and inspected (meshroom/gps-cluster-contact-sheet.jpg): supplement bottles and a desk at home — not a landmark or building.
- Workspace-wide image-density scan — the only image-dense folders are map-tile assets and renders (downtown-mvp tiles, isometric-sausalito renders), not photographs.
- Paired iPhone 16 Pro — its 65 device commands include no photos/gallery command at all (calendar, contacts, health, location, music, reminders…), so the phone's photo library cannot be pulled through Muse.
Blocker 2 — this VM cannot run the full pipeline even with photos. Meshroom's dense-reconstruction (DepthMap) node requires an NVIDIA CUDA GPU; this VM has no GPU. The documented CPU fallback ("Draft Meshing" from the sparse SfM point cloud) exists but yields a coarse blob, not a usable landmark model, and Meshroom's meshing guidance assumes ~32 GB RAM vs ~6 GB usable here. A partial CPU run would have produced misleading evidence, so it was not attempted.
What Ros would need to shoot (to make this test runnable)
One distinctive, walk-around-able subject for the Sausalito map — e.g. the Plaza Viña del Mar fountain, the ferry landing building, or one distinctive house: - 25–40 photos, a full 360° loop around the subject in 2–3 height rings (low / eye-level / slightly high where reachable), 70–80% overlap between consecutive frames — move a step or two, shoot, repeat. - One focal length the whole set (no zoom changes, no digital zoom), subject filling most of the frame, a few closer detail passes at the end. - Even light: overcast or golden hour; avoid harsh midday shadow and, where possible, frames full of moving people/cars. - Then run Meshroom on a machine with an NVIDIA GPU (Ros's own desktop, not this VM): drag the folder in, default photogrammetry pipeline, export the textured mesh (OBJ/glTF) into the three.js scene as a hero landmark.
Verdict — Reuse later
The idea is sound and the tool is healthy; it is gated on two things only Ros can supply — the photo set and a GPU host. Neither exists today, so there is nothing to adopt yet and no reason to skip the concept.
Draft test record — Subject C
- Find: #10 — Meshroom (alicevision/Meshroom)
- What ran: Not run. Photo-set hunt across the workspace, media library, chat attachments (GPS-cluster contact sheet inspected), and the paired iPhone (no photos command exists); environment check against Meshroom's documented requirements.
- When: 2026-11-20
- Outcome: NOT RUN — (1) no ≥8-photo overlapping set of one subject exists in Ros's reachable photos (media library empty; only GPS cluster is supplement bottles/a desk); (2) Meshroom's dense pipeline requires an NVIDIA CUDA GPU and this VM has none (CPU Draft Meshing would not produce usable evidence). Tool itself is current (2025.1.0, Aug 2025).
- Output:
~/workspace/finds-tests/maps-trio-2026-11-20/meshroom/gps-cluster-contact-sheet.jpg(hunt evidence); photo-set spec for Ros in this report. - Reuse proposal: Reuse later — rerun when Ros shoots the specified 25–40-photo loop of one Sausalito landmark and a GPU host is available.
Closing note — how the three combine (or don't) with the deck.gl-adopted route
deck.gl (Adopted, slate 2.2) and these three finds are not competitors; they sit in different layers of the same map:
- deck.gl remains the data-first web layer — pan/zoom map, OSM-derived line/polygon layers, labels, interaction. Nothing in this test displaces it.
- blosm (Adopt, scoped) feeds the 3D branch beside it: it turns the same OSM extract + SRTM terrain into correct, draped 3D geometry offline and exports GLB for the three.js scene — and doubles as the reference render for validating the hand-rolled Data-First OSM Typology output (roof rules, level defaults, road-class merges are all legible in its results). One gap to plan around: roads cross the Blender→glTF bridge as curves and arrive empty, so the web scene should keep drawing roads from OSM/deck.gl-style layers rather than from the GLB.
- The procedural generator (Skip) adds nothing to either branch: deck.gl/typology already does parametric variety with the right (pitched-roof, real-footprint) vocabulary.
- Meshroom (Reuse later) is the hero-asset feeder for the same 3D branch: photogrammetry meshes of individual landmarks, dropped into the three.js scene where OSM has only a footprint. It is orthogonal to deck.gl and to blosm — and for Pischana itself it likely never applies (Ros has no photo access to the village); its home is Sausalito, where he can shoot the set.
Net pipeline shape after this test: OSM + DEM → (blosm bake/QA) → GLB into three.js for the village scene; deck.gl for the data/map layer; typology code for anything blosm can't express; Meshroom later for photographed hero landmarks.





