Skip to main content
100%

Gist 350b55fdacbabd690b789c7958fb7995

✓ Published0🌍 Public
Aandybak
Last edited Apr 10, 2020
Created on Apr 10, 2020

This visualization generates downloadable 3D building models from a geospatial database. It queries building footprints within a specified radius of a given latitude and longitude, extrudes each polygon to a height proportional to the building’s height, and centers the resulting scene on the buildings’ centroid. The code uses Django’s GeoDjango for spatial queries, Shapely for polygon manipulation, and trimesh for scene creation and GLB export. The final output is a binary glTF file containing the extruded building geometry.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 63540e65c30a453a7e2e9b0345aa42ce

This example renders a 3D cityscape from geospatial building footprints, showing extruded building volumes colored in a uniform teal tone. It queries buildings within a given distance of a latitude/longitude point using Django’s GeoQuerySet (`outline__dwithin`) and converts each polygon outline with Shapely, then extrudes it with Trimesh’s `creation.extrude_polygon`. The scene is centered via a translation matrix, scaled, and exported as a GLB file using Trimesh’s `exchange.gltf.export_glb`. The visualization highlights building heights relative to their footprint areas.

Aandybak
89% match
Loading thumbnail…

Gist 6ccd9c4ef2c862306f62bc847ac036d3

This WebGL visualization displays 3D models sourced from Google Poly, processed from original scene data into canonical JSON format. Using Python scripts, the code extracts embedded asset information from HTML pages and decomposes transformation matrices into rotation, translation, and scale components. The visualization renders the reconstructed 3D scenes through WebGL, leveraging the parsed model data and file type metadata from the Poly asset structure.

Aandybak
72% match
Loading thumbnail…

Gist 8183aad3764bedf7ab23187c08fd1f12

This example renders a 3D mesh of a Brazier-shaped polyhedron, built from a JSON specification and processed through a sequence of geometric operations. The shape starts as a uniform hex grid prism, then applies operations such as `FaceScale`, `Extrude`, and `Kis` to selected upward-facing faces, producing a sculpted, bowl-like form with a faceted interior. The model uses a hex grid type with prism parameters and a "Dirty Metal" appearance preset, suggesting a material-based shading pipeline. The visualization relies on the JSON’s operation list to transform the base geometry, with disabled operations like `Lace` indicating optional refinement steps that remain inactive in the final output.

Aandybak
67% match
Loading thumbnail…

Gist 97014fa0c26abd2904c7ba9d22ab9e57

This visualization maps the structure of Google Poly’s 3D asset files by parsing embedded JSON from saved HTML pages. It converts transformation matrices into quaternions, translations, and scales, then categorizes each file’s role (e.g., original glTF, USDZ, OBJ) using role IDs. The code processes thousands of assets, extracting metadata to reveal how different file formats and roles are distributed across the collection. It relies on Python’s `json`, `re`, `math`, and `os` modules for data extraction and matrix decomposition, with the final output intended for further analysis or charting.

Aandybak
67% match
Loading thumbnail…

Gist e30aac4bd8656b6d68668de3e25042f7

This visualization showcases 3D photogrammetry assets converted from FBX files to GLB format for web display. It uses the FBX2glTF command-line tool to convert models, then generates an HTML scene with A-Frame’s `<a-gltf-model>` component to load the resulting GLTF files. The shell script also converts PNG textures to JPG using ImageMagick, rewrites the GLTF references accordingly, and packs models into binary GLB files with the gltf-import-export library, creating a gallery of textured 3D objects.

UUtopiah
67% match
Loading thumbnail…

Gist 69cfbb7f237e72e9bcbd21744278a5f8

Procedurally generated from a base grid, this scene depicts a small town of varied houses topped with domes, built using the Antimony graph modeling library. The code constructs a jittered grid, extrudes random-height house blocks, and splits them into walls and domes, which are then shaped with lofting, shelling, and dome operations. A beveled and medial ground plane is added, and the final model appends all parts together. The example demonstrates Antimony’s grid, face-selection, and transformation APIs for generative architectural form.

Aandybak
66% match
Loading thumbnail…

Gist 786ba24d8dc3ab6d65192a9b8b74b2a5

This visualization uses the Google Poly API to display a catalog of 3D assets, letting viewers browse objects by category and format. The code fetches asset metadata from the Poly discovery document and renders it with a custom interface built on JavaScript. A force-directed layout via `d3.forceSimulation` positions thumbnail nodes, while hover interactions reveal asset details. The visualization relies on the Poly REST endpoints for listing and retrieving assets, showing how API data can be transformed into an interactive spatial arrangement.

Aandybak
65% match
Loading thumbnail…

Gist fcaa6cc1968b4cd0eac0f15d1f0ff3f4

This visualization maps geographic data onto a three-dimensional globe using D3.js and Three.js. It renders landmasses as extruded polygons via `d3.geoPath` and converts them to Three.js geometry, while a `d3.forceSimulation` drives the rotation of the globe. The example also applies a canvas-based texture through `getImageData` to overlay graticule lines and subtle shading, and it animates the camera with `transition.attrTween` to smoothly orbit the planet. The data comes from a GeoJSON source embedded in the gist file.

YYannael
64% match