3D Scanning and Printing

Subdivision-BDMH -Demo

Subdivision-BDMH -Git repo
TF4DGS -Git repo

3D Printing (Subdivision as a generative system_Insp-BDMH)

To start with, I wanted to explore my deep fascination with repetition and complexity/resolution at different scales. It first struck me when I explored more about Mandelbulb fractal geometry, where the resolution is limited by the capacity of the viewer/experiencer, and with each "zoom/dive in" you see more and more and find out more and more.

This is not necessarily well explored in architecture, but Benjamin Dillenburger and Michael Hansmeyer's works from the 2010s were exploring this. The main perspective was not to model the final design but to design the process. With that, they utilized a modified Catmull–Clark subdivision, where in each step the subdivision rule is applied.

It also reminds me of Conway's Game of Life: with really simple sets of rules and an initial state, different patterns emerge, and within that context, describing the geometric definition of a particular stage becomes more information-dense, and it becomes easier to just save the function/rule sets and the initial state, and with minimal computation you can reach the particular state. And for complex systems, this becomes more and more substantial.

In computer graphics, it's also well explored, especially in rendering, and subdivision was initially explored within that context.

To start with, I retrieved my initial inspo from Benjamin Dillenburger and Michael Hansmeyer's works on Digital Grotesque and Subdivided Columns.

I had past experience exploring and applying Hansmeyer's subdivision utilizing Rhino and Grasshopper. But to minimize the exploration barrier, I wanted to model a really simple subdivision engine with a clean and basic Python script in the background that computes and gives people without a modeling background the opportunity to explore the iterations more.

To achieve this, I initially utilized the Polyscope library, which is a C++/Python viewer.

This is my full project -Git repo

Later on, when I finalized the subdivision engine, I utilized AI (Claude Code - Claude Opus 5.5) to mimic my portfolio website's design aesthetics.

To give a glimpse of subdivision: it starts with a basic geometry (could be a single mesh surface, pyramid, cube, sphere or any other intended mesh geometry). From there, the weights for faces, edges, corners, etc. are chosen. These are the initial base "Geometry recipe". From there, in each stage the subdivision occurs in the model, and progressively and recursively you get more and more granulated geometry, and the resolution becomes limited by what is viewable and executable (printable with an FDM printer with a 0.4mm nozzle in my case).

Here are some geometry examples where, even though no attractors were used, super complex, intricate and beautiful shapes are emerging.

This was my initial print. I wanted to print a 6-axis cross trapped in a cube frame while keeping the cube's outer faces minimal and the inner parts quite expressive with subdivision. Unfortunately, I didn't account for the tolerances, and the support structures got fused with both the central cross and the cube cage.

Afterwards, I adjusted my settings, scale and clearance, and managed to print a relatively clean model in a single run with minimal supports only at absolutely necessary points.

After doing this, I got more and more into this duality of minimal and complex design and how they speak to each other. From my past experience, I was also fascinated with the lithophane technique in 3D printing and thought, why not integrate it?
I adjusted the engine a bit and explored the possibility of having a super sleek sphere with subdivision only on the inner surface.

This was my print with one as the thinnest parts as a single layer and other one with double-layer walls.

And this is how it turned out. :)

3D Scanning (Temporal Fields 4D Gaussian Splatting)

After a while of enjoying and having fun with subdivision, I started exploring the 3D scanning potential as well.
I had extensive experience in reality capture with different sets of tools: laser scanners (both low-res real-time and high-res static with sub-millimeter accuracy),

These were the tools that I had previous experience with:

Now to start with, for image reconstruction and matching, I used the COLMAP library (which is a general-purpose Structure-from-Motion (SfM) library) by Johannes Schönberger, Jan-Michael Frahm and Marc Pollefeys @ETH Zurich & UNC Chapel Hill (and all the other countless contributors).
For Gaussian training, I used the open-source LichtFeld Studio app by Janusch Patas (and ofc other contributors).
For installation, I followed the installation steps from the respective GitHub repos.

I started with splatting my desk, which I quickly captured in low light with a DJI Osmo Action 6 camera (PS. not the best setup.). While the installation was smooth and flawless, at the start of the training I had several hiccups regarding the initial image dataset construction, but they were easily resolved.

This was the initial start of the training; it looks quite promising.

Here it is at step 10k, not the best, but I wouldn't complain given my setup.

And here is my finished splat.

Afterwards, as a bigger goal: I have always been fascinated by the speed of development of Gaussian splat research, and I got increasingly fascinated by 4D Gaussian splats. Eventually, I wanted to have a multi-camera setup for my DIY home training setup, but currently I have 3 cameras of completely different types (mirrorless camera - Fuji X-T5, my personal iPhone 15 Pro and DJI) (generally a really bad idea, but worth giving a shot).
So I wanted to test scanning our assembled large-scale pavilion in the new MIT Architecture building, the Metropolitan Warehouse (MET). To test the capabilities of reconstruction and the possibility of merging a multi-camera setup in a single training, I took videos with my iPhone and DJI and photos with my mirrorless camera. I extracted frames from the videos and selected the sharpest ones using the Sharp Frames tool.

Now that I had tested and verified that the multi-type camera setup works for static Gaussian splatting training, it was time to build a small rig for testing 4D Gaussian Splatting.
This is my full project -Git repo

To start with, to have a preliminary trackable base and dimensional accuracy, I checked the current options and found the ChArUco board from OpenCV (which is a combination of a chessboard and an ArUco marker setup), adapted it to my size and printed it.

This was my preliminary camera setup (horrible and unstable, wouldn't recommend, but it was okay for a prelim test). Left view: mirrorless camera, central view: iPhone and right view: DJI.

Now the question was how we can synch them. In movies, the synch is normally done with a clap, and inspired by that, I dropped my small box and cut all the videos from the moment the box hit (not the best way, as the cameras are recording at 30fps, so the error/shift margin is more or less 1/30s).

Here I assembled everything in Premiere and cut it into two distinct test cases:

Here are my prelim trained outputs:
The yougurt test is semi succesfull and I am happy with the result.

Cant say same for textile test. Still big WIPPP : )

AI usage

AI (Claude Opus 5.5 - for subdivision, and GPT-6.1 Sol in Codex - for the TF4DGS project) was initially used as a bug- and error-fixing tool. Later on, as the baseline was set, it was used in optimising and creating the subdivision engine and the UI adaptation. For Gaussian splatting, in the shift and development from 3D to 4D Gaussian splats, it was heavily utilised for ideation and execution of the technical framework.