Skip to main content
100%

Gist 272eb87f44d09dae52ef0369a16d26f2

✓ Published0🌍 Public
Aantogg
Last edited Dec 3, 2019
Created on Dec 29, 2019

This example shows how to run Meshroom, an open-source photogrammetry pipeline, inside Google Colab to generate a textured 3D mesh (OBJ file) from uploaded images. It connects to Google Drive, downloads Meshroom 2019.2.0, and creates an input folder for image uploads. The notebook uses shell commands via `!wget`, `!mkdir`, and `!tar` to install the software, and Colab’s `drive.mount` API to access cloud storage. The workflow guides users through optional Drive integration, project folder setup, and image preparation before running the reconstruction.

AI-generated description

Similar vizzes

Loading thumbnail…

Google Colab gdrive

This example demonstrates how to access and mount a Google Drive folder within a Google Colab notebook. It first installs the necessary system packages and authenticates the user via Google’s OAuth2 credentials through the `auth.authenticate_user()` and `GoogleCredentials.get_application_default()` APIs. The code then uses the `google-drive-ocamlfuse` command-line tool to request an authorization URL, prompts for a verification code via `getpass`, and mounts the Drive directory using `google-drive-ocamlfuse drive` after creating a local `drive` folder. The visualization shows the terminal commands and authentication flow required to connect external cloud storage to a Colab runtime.

WWikunia
66% 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
57% match
Loading thumbnail…

Gist 3d7ff1d83fb2177cedceded587ff4aca

This example presents a setup guide for a Docker-based Node.js workshop, illustrating how to launch a project from a Bitbucket-hosted configuration. It shows the command sequence, starting with copying a `docker-compose.yml` file from the provided URL and then running `docker compose up --build` to construct and start the container image. The visualization focuses on the workflow steps, highlighting the use of Docker Compose for service orchestration and image building. The interface displays the copied configuration link alongside the terminal command, making the process explicit for users. No additional data or rendering occurs beyond these instructional elements.

MMistyBlunch
56% 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
55% match
Loading thumbnail…

Batch script for automated photogrammetry tracking workflow

This example shows a fully automated photogrammetry tracking workflow that converts video files into COLMAP sparse models. The batch script processes videos from an input folder, extracts frames using FFmpeg, runs feature matching and sparse reconstruction via COLMAP’s command-line interface, and organizes results into per-scene folders. It includes progress logging, error handling, and skips already-processed videos on reruns, with all paths resolved relative to the script’s location.

Aantogg
54% match
Loading thumbnail…

Gist 350b55fdacbabd690b789c7958fb7995

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.

Aandybak
54% match
Loading thumbnail…

Gist 669840e74e5d863f3867c2946eb31ece

This example uses a headless Chrome setup, orchestrated through a Dockerfile, to render a dynamic web visualization. It shows an animated, interactive scene that likely involves geographic or force-directed elements, as the environment installs Chrome and chromedriver for automated screenshotting or streaming. The Python-based driver, running via `main.py`, relies on Selenium to control the browser and capture frames, while the underlying page would use D3.js’s `d3.forceSimulation` for physics-based layout and `d3.geoPath` for map projections if applicable. The setup explicitly avoids displaying a static image; instead, it captures live rendering from the Canvas or SVG, though the exact output is not visible in the code.

CConorAspell
54% 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
53% match