I am currently developing an experimental script inspired by the PixPort Lagos project by SA lab. My goal is to generate similar modular, labyrinth-like volumes using an algorithmic approach.
Issue:
I have completed a first iteration, but I’ve run into some challenges during the discretization and curve-sorting stage. As seen in my “rough attempt” (attached below), the geometry is currently “clumping” together into a dense, unorganized mass. I am struggling to implement a clean logic for filtering these curves to keep only the primary, long-reaching paths while maintaining a readable structure:
Generate a vector field based on the site/input geometry.
Extract streamlines from the field.
Discretize and filter the curves.
Convert the resulting lines into modular architectural volumes.
Questions:
Filtration & Collision: What is the best principle for sorting and filtering these curves to ensure the final modules don’t conflict with one another? Should I be looking into proximity-based checks or specific culling patterns?
Field Optimization: How can I refine the initial vector field to achieve a more uniform and parallel distribution of streamlines, avoiding “knots” or overly dense clusters around attractors?
I have attached my script and would be incredibly grateful for any advice, corrections, or alternative workflow suggestions you might have.
watching the video, I believe it is a voxel-based strategy similar to the techniques introduced and explored by Gilles Retsin, Manuel Gimenez-Garcia, Daniel Widrig and others at the Bartlett, circa 2015-2016 (linke this one, for instance: Bartlett Students Develop New Method for 3D Printing Concrete | ArchDaily). There was a bunch of projects based on dicretizing trajectories into voxelized space.
The key giveaway in the video is the brief sequence around 0:18 (don’t be fooled by the morph effect, it’s just for show):
. discretize a box volume into voxels
. split each voxel into 2 “halves”, for example along the X axis, so you have a Y-up and a Y-down half
. for each half, get the volume centroid and get the closest curve’s tangent from that
. if the closest curve is outside the voxel, do nothing, otherwise:
. approximate the tangent vector to a _ | / or \ segment (vertical, horizontal or diagonal)
. join all the resulting segments inside each voxel into 2-segments polylines
. fillet the resulting polylines’ sharp corners
. extrude them to form the volumes
Now, some of the above steps might not be 100% correct for the case, but they are just to give you a start with the logic.
Hello
I didn’t read the whole thread, I made some components in Nautilus to clean polylines
One to cut every “angle of turn” and one to suppress overlap (beware of distance between curves if too low the component can be very slow, better to kill the process)
Hi, I don’t have the time to check .gh files at the moment, but I fished something off of my 2017 archive. The project I was studying is the Bartlett RC4 Voxatile: https://www.behance.net/gallery/52165009/RC4-Voxatile
Back then I cooked up a gh definition that does something very similar, just straight from the field vectors sampled at the voxels’ centre (but you can easily adapt it to work by sampling curves tangent vectors):
discrete_test_01.gh (63.7 KB)
The logic is explained step-by-step in the definition (I misremembered a couple of them when I first posted straight form my bad memory…).
I ended up using it to print customized gift wrapping paper
