The chain
Six steps. The two with a dashed edge happen only when asked for, because they are public.
- The headset keeps picturesIts app keeps a picture from the passthrough camera every 5 cm or 6 degrees of head movement, with the headset's own position and direction for it and an 80 × 60 grid of depth rays behind it. Pulling the trigger on a thing names it as the object. The headset has no lidar: its depth comes from its two tracking cameras.
- Live, if asked forWhile it scans, the app also sends one depth reading per ray to the laptop over the USB cable. The laptop keeps one per 2 cm of surface and passes them through the relay; the live page draws each as a Gaussian the moment it arrives. These are placed, not trained.
- The laptop trains the splatThe headset's positions are used as they are, with no structure from motion. The pictures are cropped round the object and Brush trains the Gaussians for 8,000 steps, about two minutes on a laptop's graphics card. A tenth of the pictures are kept back and compared with what the splat draws from their positions.
- From splat to solidThe splat's depth is drawn from every camera position and voted into a grid: outside where enough cameras see past a cell, surface where they see it, solid where none could see, so the body is closed. It is cut flat on the surface it stood on.
- SlicedThe solid is scaled and sliced for a Bambu H2C with the slicer's command line, which reports the time and the grams. Nothing is sent to a printer.
- Published, if asked forOpen3D reads the trained splat and writes it compressed, about a tenth of the size; that file, the solid, a render and the print files go into this site's repository. Open3D does not make the splat: it has no training. The camera pictures are not published.
What has been checked, and what has not
The tools
Plain files, as they are used; nothing here is built. Python (numpy, scipy, numba, Open3D, scikit-image, Pillow, playwright), PowerShell, and one C# script for Unity 6 with Meta's XR packages. Their defaults name folders in the user's home folder. The viewer is view.html and the live page live.html: their source is the page itself, with scans.css.
On the headset
| PrintWhatISee.cs | The headset app (Unity, Meta's passthrough camera and depth): keeps a picture, the camera's position and a grid of depth rays every 5 cm of head movement; the trigger names the object; the splat sensor sends one reading per depth ray for the live view. |
| PrintSeeBuild.cs | Builds the app's scene and its Android package. |
| compile_check.py | Compiles the app's scripts in seconds, without a build. |
| printsee_build.ps1 | Runs the Unity build without a window, watching the disk. |
One sitting
| start_quest_scan.ps1 | The one command: scan, splat, solid, print file; -Live and -Publish send to this site. |
| scan_session.py | Waits for the headset to be worn, starts the app, follows its log, then runs the steps below. |
| quest_scan.py | The laptop's part: checks the scan, writes the training set, trains the splat (Brush), cuts out the object, makes the solid, slices it, draws the pictures. |
From a phone
| phone_scan.py | A phone's recording (a ROS 2 bag from MuseLog's Scan in 3-D) to a splat: takes the pictures out, works out where each was taken from (structure from motion), sets up, middle and a guessed size, trains, draws the pictures. |
| phone_scan_worker.py | Runs on a computer with a graphics card: asks the relay for scans that phones sent, makes the splat of each, publishes it here, and takes down what its owner removed. |
The parts of the laptop's work
| scan_lib.py | Reads a scan folder; the headset camera's model; writes the training set in COLMAP's layout; reads and writes splat files. |
| splat_render.py | Draws a Gaussian splat on the processor: colour, depth and coverage from any camera position. |
| scan_solid.py | From splat to solid: the surface the object stands on, the object's own Gaussians, depth from every side voted into a closed body with a flat base. |
| slice_h2c.py | Slices an STL for a Bambu H2C with the slicer's own command line; reports time and grams. |
| scan_view.py | Serves the viewer (view.html on this site) on the laptop and to the headset through the USB cable. |
| fetch_vendor.py | Fetches the two libraries the viewer runs on, checked against recorded hashes. |
A room seen from one spot
| scan_view_folder.py | Gathers an early sitting's pictures into one folder. |
| scan_mono_depth.py | Depth for pictures that have none: a depth network's map per picture, pinned to the headset's own measurements. |
| scan_room_model.py | Fuses those depth maps into a coloured shell of the room and a diorama to print. |
Checking the method
| scan_synth.py | Draws a made-up scan of a known model, at the headset camera's geometry and with noisy depth. |
| scan_gate.py | Measures the result against the known model and says pass or fail. |
To this site
| scan_publish.py | Puts a finished scan here (the splat compressed by Open3D), takes one off, and writes these pages. |
| scan_pages.py | The words and the markup of the list of scans and of this page. |
| quest_splat.py | The live view's sender: takes the app's depth readings over the USB cable, keeps one per 2 cm, records them, passes them to the relay. |
| start_quest_splat.ps1 | The live sender on its own, without a scan. |
| splat_live_check.py | Sends a labelled test pattern through the public relay and checks that the home page draws it and lets it go. |
| SCAN_README.md | The notes kept with the tools: how to run them, every file, the method, what was checked and what was not. |