Updates:
20mm cubes of several Triply Periodic Minimal Surfaces (TPMS) as explored at Generative Parametric Infill Geometries printed with MSLA (Anycubic Photon Mono 4K) at 35 μm XY, 50 μm Z:
Most of the cubes were printed without support, the cylindrical and spherical projections required supports.
20mm and 40mm cubes of TPMS mounted on canvases:
Updates:
As I progress I will update this blog-post.
Infill geometries are geometries which are continuous, repetitive or periodic; they fill a boundary defined geometry aka outer form often defined via meshs. Let’s dive into some of the simple geometries and then looking at some more complex structures:
Implicit geometries are geometries defined via f(x,y,z) = 0 defining their surface, the boundary between inside and outside and they are ideal to define repetitive or periodic 3D infill geometries.
Sphere: x2 + y2 + z2 – r2 = 0
When you ever tried to compose a sphere as a mesh, you know there are many ways to do so, and all are more complex than this simple description, and as you realize, the formula is perfect, it’s not an approximation – this is the nature of implicit formula. When you try to visualize an implicit formula, then you need to discretize and there the approximation takes place, as a mesh or as voxels.
Another nifty property of the sphere, it is the minimal surface to circumvent a volume, and through this blog-post, the minimal surface will become a common theme.
Cube: max(abs(x),abs(y),abs(z)) – w/2 = 0
Plane: z = 0
As I render only -10 to 10 to each axis, it creates a small plate:
Let’s move to the world of minimal surfaces, so called Triply Periodic Minimal Surfaces (TPMS), those can be expressed in implicit form and have some properties as sought for infill geometries.
In differential geometry, a triply periodic minimal surface (TPMS) is a minimal surface in ℝ3 that is invariant under a rank-3 lattice of translations. These surfaces have the symmetries of a crystallographic group. Numerous examples are known with cubic, tetragonal, rhombohedral, and orthorhombic symmetries. Monoclinic and triclinic examples are certain to exist, but have proven hard to parametrise.
Wikipedia: Triply Periodic Minimal Surface (TPMS), retrieved 2023/02/08
One of the simplest yet powerful formula:
Schwarz P: cos(x) + cos(y) + cos(z) = 0
increasing the frequency or scale of the structure:
By extending the formula with +a, we can animate it:
Schwarz D: sin(x)*sin(y)*sin(z) + sin(x)*cos(y)*cos(z) +
cos(x)*sin(y)*cos(z) + cos(x)*cos(y)*sin(z) = 0
Neovius: 3*(cos(x)+cos(y)+cos(z)) + 4*cos(x)*cos(y)*cos(z) = 0
C(Y) Surface: sin(x)*sin(y)*sin(z) + sin(2x)*sin(y) + cos(x)*sin(2y) + sin(2y)*sin(z) + sin(2z)*sin(x) + cos(x)*cos(y)*cos(z) + sin(2x)*cos(z) + cos(x)*sin(2y) + cos(y)*sin(2z) = 0
Fischer Koch: (cos(x)*cos(y)*cos(z) + cos(z)*cos(x)) –
(cos(2x)+cos(2y)+cos(2z)) = 0
S Surface: cos(2x)*sin(y)*cos(z) + cos(2y)*sin(z)*cos(x) +
cos(2z)*sin(y)*cos(y) – 0.4 = 0
Gyroid: cos(x)*sin(y) + cos(y)*sin(z) + cos(z)*sin(x) = 0
FRD: 8 * a*cos(x)*cos(y)*cos(z) + b*(cos(2x)*cos(2y)*cos(2z)) –
c*cos(2x)*cos(2y) – d*cos(2y)*cos(2z) – e*cos(2z)*cos(2x)
Let’s explore this form more thoroughly, we animate a, b, c, d, and e and see what it does, essentially we animate -1 to 1 in sinus, 0 eliminates of the chunk of the formula:
Gyroid Skeletal: 10*cos(x)*sin(y)+cos(y)*sin(z)+cos(z)*sin(x)) –
0.5*(cos(2x)*cos(2y)+cos(2y)*cos(2z)+cos(2z)*cos(2x)) – 14
P Skeletal: 10*(cos(x)+cos(y)+cos(z) –
5.1*(cos(x)*cos(y)+cos(y)*cos(z)+cos(z)*cos(x)) – 14.6
By changing the last substraction of 14.6 to 10 or 8, the structure get more dense – ideal to use.
The P Skeletal connects 6 arms to each other.
IWP Skeletal connects 8 arms to each other.
Schwarz D Skeletal connects with 4 arms to each other.
The above “skeletal” minimal surfaces are ideal for lattice structures, likely most usable in context of voxel-based 3D printing approaches, such as SLA, SLS, SLM and so forth, but less ideal for traditional FDM where the lattice is sliced Z-planar again kind of defeating the overall purpose of lattice structures.
D Surface: cos(x)*cos(y)*cos(z) – sin(x)*sin(y)*sin(z)
As Juergen Meier created a variant, adding a, which gives these variants:
providing a structure using 4 arms to connect each other.
Slic3r and Prusa Slicer are providing gyroid infill pattern since early version, but beyond that it seems no to little development happened since (2022/12).
Let’s see how implicit geometry can be transformed into slices (FDM) or voxels/pixels (SLA, SLS etc)
Pros
Cons
Pros
Cons
Here some early G-code for FDM 3D printer using PyImplicit tool tracking the implicit surface as 2D contour:
The implicit surfaces only define the surface, either:
In order to create watertight meshs the volume needs to be limited with a boundary box, and Marching Cube is performed from outside to get proper mesh to post-process afterwards.
Now you may wonder, what’s the fuss with all those forms, why doing this complicate implicit form, why not just create a few forms as meshs right away and repeat them orderly – well, here it comes why:
Changing the frequency or scale s0 and s1 can be achieved by:
znorm = (z-zmin) / (zmax-zmin)
s = (1-znorm)*s0 + znorm*s1 or
s = lerp(s0, s1, znorm)
f = surface(x*s, y*s, z*s)
This shows the power of generative geometries, we simply can define the scale or frequency of a geometry at any point, given we transit within reason and not too sharply to cause discontinuty.
Alike changing thickness:
znorm = (z-zmin) / (zmax-zmin)
t = lerp(t0, t1, znorm)
f = abs(surface(x,y,z)) – t
What looks very complex is done quite simply with:
znorm = (z-zmin) / (zmax-zmin)
f = lerp(surface1(x,y,z) , surface2(x,y,z), znorm)
This is quite powerful property, to be able to morph from one implicit form to another with such a simple formula.
Contineous Transitions:
Discontinueous Transitions:
Algebraic addition has the effect of apply one geometry within another, alike recursion:
Algebraic multiplication has the effect of clipping, or geometrical intersection:
One can map the coordinates, and create a cylindrical gyroid, where former X & Y become distance and rotation angle, and Z remains as is, and so spherical projection is possible as well, or even feed coordinates through implicit formula itself:
Next blog-post(s) I will go into further details utilizing TPMS in Additive Manufacturing (AM) like FDM/FFF, SLA, MSLA, SLS, MJF or SLM – each one of them have unique features and limitation for using those Parametric Generative Infill Geometries.
In case you wondered of the different styled visualization through this blog-post, let me show you the different approaches to discretize implicit defined surfaces.
The code is rather simple with OpenSCAD yet rather slow: either skin is true or false, and delta determines the thickness of the skin if enable:
t = 1;
r = 20*t;
st = 1/2;
delta = 0.2;
function schwarz_p(x,y,z,s=1) = cos(x*s) + cos(y*s) + cos(z*s);
skin = true;
for(x=[-r:st:r])
for(y=[-r:st:r])
for(z=[-r:st:r]) {
f = schwarz_p(x,y,z,360/20/2);
if(skin && abs(f)<delta) // -- skin only
translate([x,y,z]) cube(st);
else if(!skin && f<delta) // -- inside/outside
translate([x,y,z]) cube(st);
}Rendered via voxelation:
Rendered in OpenSCAD via marching cube algorithm with Level Surfaces:
Following experiments were done with Spirula/Implicit3 within the browser, the implicit formulas are rendered in realtime at 100-500 fps using OpenGL’s GLSL (GL Shader Language):
One has to clip the formulas with a cube in order to have a limited set, otherwise you get a full screen looking at infinite X, Y & Z, here Schwarz P:
In order to create a mesh, I developed PyImplicit which utilizes Numpy library to calculate the implicit formula fast, and then run a Marching Cube algorithm over the result in order to get a discrete mesh like STL, OBJ, or 3MF to process further for 3D printing.
*) some of my larger prints I attach RFID tags, e.g. as on top of the variable frequency Schwarz P print, which I store the print UID from my Prynt3r job which logs all my prints with all settings and webcam snapshots. In future blog-post I will illustrate my NFC/RFID setup.
And Polyviuw is a small mesh viewer using Polyscope Python as backend to display it as mesh:
It is easy to create huge files when exporting an implicit generative infill geometry and one ends up with a 700MB binary STL file, which becomes hard to view at least on my system. To handle complex outer forms, with complex inner geometries I estimate reaching multiple gigabytes large files – let’s see.