How to create complex Voronoi lattices in nTopology for printing in FDM, DLP and Powderbed!
We cover how to create complex, strong, organic, yet lightweight shapes for 3D printing using a powerful next-generation generative software, called nTopology, and then compare the results on three different 3D printing methods- FDM, DLP (P3) and Powderbed (SAF)!
-
Step 1: Overall Workflow
This is a tutorial I've wanted to do for a long time.
For YEARS, every time I went to a 3D printing tradeshow or looked on reddit, all I would see are these amazing complex, 3D printed lattices:
And as we've discussed before, this sort of random lattice/Voronoi shape is fast becoming the "3D Printing Aesthetic", letting you immediately know what process was used to create that object you're holding:
But how do you actually MAKE those organic, complex, curved random lattice shapes for 3D printing?
You can't manually CAD them up, that takes too long.
I've done it once before using Rhino + Grasshopper, but it was a pain to map back onto complex CAD shapes, if you read that tutorial.
I've even done it once in MeshMixer for a fun Halloween project for a local Stratasys reseller, PADT:
But there's a hugely powerful next gen CAD system + programming language + topology optimization tool that some of our most advanced aerospace and automotive customers use, called nTopology, and just last month, I finally got a license of nTop and got a workflow to work for me, creating quick lattices with these steps:
And THEN, instead of printing that part in ONE technology, I actually had three different parts of Stratasys print it for me in THREE different technologies, so we can see the up and downsides of each:
This is a project I've been dying to try FOREVER, and I'm super excited to show you what worked (and more important to our learning, what didn't!)
If you just want to see how the parts printed in the three different technologies, skip to Step 8 using the bar on the right.
But if you want to learn nTop to easily make complex, organic, weight-saving lattices starting with almost ANY CAD shape, for printing high-end prosthetics, automotive fixtures or lightweight aerospace parts, or just do some wild industrial design on your next project, read on!
-
Step 2: You start in CAD
While nTop does have tools to create primitives and then boolean them together, I'm a SOLIDWORKS guy at heart, so I started there.
The shape we're trying to make is sort of wrist-cast/wrist-guard for your left-hand, sitting on your skin, with a hole for your thumb at top.
(Don't @ me about the proportions, I'm not a bio-medical engineer. It's just an example.)
Here's what I did in SOLIDWORKS first:
Why did we need those overlapping yellow inner and outer bodies, when the gray shape was the one we actually care about?
Because AFTER you lattice something, in any software, you always end up with a hundred random jagged edges at the spots the lattice ends, and you need some way to 'clean up' those inner and outer edges.
I've found having extra bodies and then booleaning them all together at the end to be the simplest way. You can experiment with your own path- let us know if you have a better way in the comments!
Not to go TOO deep into how I made those yellow edge bodies, but just so you can duplicate it for complex shapes, I:
(1) offset end faces of the main body into surfaces,
(2) extended those surfaces to make cutting planes
(3) made a copy of my original gray shape and used the surfaces from step 2 to trim it away:
And the best part is that three body SOLIDWORKS file (.sldprt) can be imported directly into nTop, to kick off the FUN part of the process.
Now with our CAD sorted, let's get into nTopology!
-
Step 3: Making Implicit Bodies in nTopology
This is what nTop looks like when you first open it:
Just like CAD systems, there are ribbons of commands across the top, but on the left side, (where a SOLIDWORKS Feature Tree would be), is going to be your programming list.
The commands there will be executed in order, from top down, just like a computer program (although you can call variables and submodules to run out of order, but we won't get into that right now):
So let's bring in our SOLIDWORKS file with an "Import Part" command:
If you hit the little "?" symbol next to that command, you can check to see that all THREE bodies from our SOLIDWORKS file made it, the main body and the inner and outer caps we made:
I'm not going to go over EVERY nTop click here, just enough for you to get a sense of the logic of the software. But we definitely want to check for the three bodies now, because we're about to take the main body ('body 2' in our case) and convert it into a math-based "Implicit" body:
This is an important step in any young nTop file's life.
This means that our shape is no longer a collection of BREPs like a normal CAD file would be (nor a collection of thousands of triangles like an STL would be), but instead now an nTop MATH equation, (some describe it as a distance field).
I'm not a mathematician, I'm an engineer. So I'm not going to describe it any better than that.
But the biggest benefit to us is that CAD shapes take a LONG time to cut 100,000 holes into. But some math equations can be acted on by other math equations nearly instantly.
You'll see this as we go on.
I'll also make each body into a "variable", allowing us to call and reference that body anytime later on, without consuming it. This is the same function a variable serves in computer code, (for anyone that had to take FORTRAN in college like I did):
And now we're ready to move on. If you want to visualize my code without all the syntax, our workflow looks like this right now:
Now, let's make that Voronoi!
-
Step 4: Making the Actual Voronoi
Most of the trick of using nTopology is:
- Knowing that a certain command you need exists in the first place, and
- Knowing what goes INTO and comes OUT OF that command, and how that fits into your overall programming chain.
(We'll talk about how to find commands at the very end.)
In our case, there's a command called "Voronoi Lattice", but it requires a list of Voronoi 'seed' points on the boundary of our part, and a mesh describing our part, so this is the INTO/OUT OF:
But there's ALSO a command that puts a random set of points on the surface of a mesh (called Random Points On Mesh, duh), and a command that creates a mesh from an implicit body (Mesh from Implicit Body, duh), so now our path forward looks like this:
This is how you have to do things in programming sometimes: start with the end goal and work your way back up to the code you need.
Going and finding commands for those operations gives us this, which is the heart of this part of the tutorial:
First we make a Mesh from Implicit Body. You can control how fine the mesh representation is, but that doesn't seem to matter much at this step. (A different mesh will matter a lot later.)
Then, we use the very literal "Random Points On Mesh" command to make 100 points on our mesh. We could make more, but this looked nice, and gave a lot of 'space' for each Voronoi cell:
And finally, we use the "Voronoi Boundary Lattice" command to do something that was SO HARD in Rhino.
(Remember how much fakery went into wrapping the resulting Voronoi around our 3D shape in that previous Rhino tutorial? nTop does that automatically.
If you don't, you should go back and read the guts of this tutorial. One of the MAIN reasons I'm doing this here is that nTop doesn't really CARE what the starting shape of your body is- once you make a body implicit, you can do ANY operation to it just as easily as any other operation. The lattice should map to a complex shape just as easily as if you were doing a flat plate.)
So what does all that give us? We get a lattice yes, but look at how THIN it is:
Notice also some 'flying beams' that aren't connected to the rest of the structure, down near the thumb hole- good thing we have those inner and outer rings to boolean them with!
One thing that's always hard in nTopology is understanding the FORMAT of what you've just gotten out of a command.
Like, is that thin shape above... an STL I can export? Is it... a mathematical equation of an Implicit Body? Is it a list of points like our random points were? What IS that thing?
Luckily, you can click on the "?" next to any nTop command and get an answer on what the output of a command should be:
And this taking data in one form into another into another is the bread and butter of nTopology.
Already, we started with a CAD file, made that into an implicit math body, made that into a STL-like mesh, made that into a group of points, and now made that into a "Lattice" object:
Get used to that, it's what nTop (and computer programming) is all about.
Also you can see that each data 'type' has it's own color-coding in nTop, which I've tried to stick to in my diagrams:
So when making your flowcharts, I would HIGHLY recommend using the same color scheme for your arrows as well, so you know what TYPE of data is going where. It really does help out, when using nTop.
Now that we've actually got our Voronoi "Lattice", let's get our model ready for export and 3D printing!
-
Step 5: Getting the model ready for export
This is always a separate step in nTop, you're never just "Saving As... 3MF" or whatever.
It's usually two or three steps in fact, enough that I always plan to make it its own section in my mind.
Typically, you have to smooth things out, boolean things together, convert to an exportable file format (a mesh), and then have a separate export command.
In our case, we have to make that very thin "Lattice" thick enough to actually use, merge it with the original bodies we had, and make it into something we can export:
Of course the thicken command is just called "Thicken Body", the merge command is "Boolean Union" and export is just "Export 3MF":
Do you see how nTop is more of a programming language than a CAD program? I NEVER had to make this many flowcharts when using SOLIDWORKS!
One thing you may also notice is how the lattice we thickened has TWO layers of beams (one on top, one on bottom). If you noticed that at this step (I didn't), you're ahead of me, and will be, until after my very first print!
But it does boolean up with our inner and outer rings VERY nice:
That's always my worry when doing crazy math operations on 3D bodies (or topology optimization for that matter, where nTop got its name): Does everything boolean up nice and clean at the end?
Crashing pure math into pure math to make some random abstract shape isn't as controlled as just using a SOLIDWORKS 'Fillet' command on some edge. So I'm always worried about surface ugliness or tiny little flyaway bits that come from some consequence of two colliding math equations.
In this case, we don't seem to have a little flyaway triangles or data noise or weird protruding edges, and that makes my designer brain happy.
(I won't notice until later that the regular lattice sticks up OUTSIDE our smooth inner rings, creating bumps at every intersection, and that makes my QA brain sad.)
Next step: convert this Implicit (math) body into something we can actually export!
Remember that Implicit Bodies are really just an nTop thing, nothing else can read them or even thinks that way. So you're probably converting down to an STL-like dumb mesh for export. This step will matter a lot to the resolution and file size of your final print.
These are the mesh settings I used for my first print, (you'll see later that I should probably increase them for my later prints):
You've basically got to choose a 'key feature' and see how wavy or representative that feature comes out at different mesh resolutions.
Feature size = 1.5 mm means that's the SMALLEST feature size it's trying to preserve. For this part that was about 8 inches long, a feature size = 1.5mm led to a file which was about 4 MB, which is sort of on the small side, based on previous experience.
If I was doing this for a final version to show someone up close, I would probably increase that file size a little.
(As it turns out, it was good enough for my FDM machine, because layer lines were coarser than any waves we might have seen from too coarse a mesh.)
After that, we just have a command to "Export that 3MF" and we can finally get the file out of nTop for printing inside GrabCAD!
Notice there's no "Resolution" option on the Export Mesh command, that was done in the previous step when we made the mesh, which is why that previous step is so important. "Export 3MF" just asks WHICH mesh you want exported and shoots it to that file path you specified.
(A "Save As" command would be much easier here. But that's not how nTop or a computer program thinks.)
Also, like a computer program, you have to 'Run' this command to get the file out. It's not always obvious to me when this last step has 'Run' or not, so I usually end up changing the file name and watching that Windows folder for the new file to show up:
And we're done with the software part!
So, if you wanted to see the WHOLE workflow at once, it looks like THIS:
And there's no reason that workflow can't work for almost ANY shape you're trying to Voronoi!
I always recommend making a 'storyboard' for your nTop programs like I did, when you're trying to debug or explain your code to a friend. It's a much better starting point than trying to look at blocks and blocks of plain text code.
So I'm sure you're all wondering: HOW DID IT PRINT?
-
Step 6: How did it print in FDM? (Not Great)
Couple of things.
So you know how Stratasys FDM printing requires support material whenever the overhang gets to about 45 degrees? Well, a Voronoi print is nothing BUT overhangs:
Even rotating the model doesn't really help:
There's really no way you can orient this thing in FDM where SOMETHING doesn't overhang, which will cause problems we'll see in a second.
SECONDLY, remember how I didn't notice earlier that nTop was giving me TWO layers of lattice beams instead of one? That means each beam was probably half as thick as I was expecting, so this diameter, while still POSSIBLE to print in FDM, isn't going to be the most durable:
But I was so excited that I had generated such a complex shape so easily I had to print it right away to see!
So after a quick print during the workday:
This is how it looked coming out of the machine!
There was a LOT of support to dissolve, and since our local support bath hadn't been set up yet (we had just moved offices after COVID), I simply took home a bottle of the dissolving solution and tried to dissolve it in my own garage overnight (never do this, it will not work):
Not only is the solution horribly caustic if you spill it, this homemade approach has the added benefit of not working. The soluble Waterworks solution is designed to remove support material at around 160 F, and while my garage gets hot, it doesn't get THAT hot.
So it's not going to work, even if you wait all weekend. Like I did:
At that point I got fed up and started just pulling the support off with pliers, and ended up with this:
So what have we learned from Version 1 that we need to change for Version 2?
- I want the lattice to be ONE solid beam and not two small ones (a command change in nTop)
- Always use the professional heated support bath not your janky at-home one
- Let's increase the lattice thickness to make it more damage resistant (just a number change in nTop), and
- Wouldn't it be GREAT if there wasn't TONS of support to pick out of a Voronoi shape from every angle? (This requires changing print technology.)
I printed on FDM because that's the only tech my office had at the time.
But if you follow my tutorials, you'll know Stratasys has just added TWO new technologies into GrabCAD Print, namely a powder-bed SAF printing out of nylon PA11, and DLP P3 printing out of almost any open resin material out there.
And the best part is that nTopology is a PROCESS, not a RESULT, so I can make a few quick changes to my process parameters and export again, just like putting new inputs into a computer program!
So let's re-run the program with better inputs AND print on technology better suited for lattice printing, and make a MUCH better version 2.
-
Step 7: The Better Version
Literally hours after taking my first print out of the oven, I learned about a better command in nTop I SHOULD have used the first time, called "Voronoi Structural Ribbing" (instead of the Boundary Lattice we did use):
And better yet, the Ribbing command takes in a pure CAD body, not intermediate Implicit bodies or meshes or random points, which makes our workflow MUCH MORE efficient:
And this is perfectly okay.
When learning a new language, you are constantly exposed to new phrases which do more than a whole bunch of your simpler starting words. Learning a new programming language is no different. So we're going to use this better command going forward and save ourselves a TON of effort.
I kept the original workflow at the start of this tutorial so you could see the path I took, with the hopes that it would help you avoid my mistakes.
Also, if I was printing something SOFT, like a spongy lattice like for the sole of a shoe or rubbery TPU components to go inside a crash helmet, I'd probably still use the first double beam lattice to get my spongy volume, so that's another reason to leave it in.
Now, to get rid of those lattice bumps which might dig into someone's skin, I added an 'Intersect' boolean, to shave down the Ribbing to only the bounds of the original smooth body:
And then we do the same boolean and export commands as before, with the edges turning out even nicer (no pokey bits)!
But that's only PART of the story on how to make this print better.
Remember that we have two OTHER technologies we can try, P3 (DLP) and SAF (powder bed) each having their own advantages on this type of model:
Let's compare how each one did.
-
Step 8: Comparing three Print Technologies at ONCE!
Here's what the overall comparison looks like:
Let's look at how each compares to FDM in turn, starting with Origin first.
If you want to go deeper into Stratasys P3 Photopolymer technology, click here, but basically it's a UV-cured, photopolymer resin, similar to a Formlabs or a Carbon.
You generally have smoother prints than FDM and a wider material selection, since you can put a lot of different resins inside the tank.
One of the main differences is in how support is used and generated:
With Origin being so new to the Stratasys family, you do currently need to go to a 3rd party software to generate support (lots of people choose NetFabb), but the plan in the future is to have all the support generation done inside of GrabCAD Print as well.
Luckily, expert Applications Engineer Kyle Babbit, who printed these Origin parts for me in our San Francisco office, says the burden of support generation and removal is WAY easy:
"Popping them out like cardboard game pieces" actually sounds pretty soothing, compared to the HOURS of manual picking I had to do with FDM.
One of the other big differences between FDM and P3/Origin is the much more open material categories of P3. Here are the broad groups of Origin materials I've talked about before:
And here are how they relate to some of the more well-known FDM material properties:
And with the ability for Origin Open Material License (OML) users to put ANY SORT of resin they want in their tank and tune every single print setting, the choices are much broader than FDM.
Because of this wider material set and due to the different physical processes involved in printing and support removal, I would probably stay above 5 mm thickness for FDM ABS/ASA lattices, but you could probably go even smaller for Origin, if you choose the right material:
It was a lot smoother in Origin, too.
If you want to learn more about the Origin materials and support generation process, check out this tutorial Kyle helped me write about Origin + GrabCAD Print last month: https://grabcad.com/tutorials/how-to-use-grabcad-print-for-p3-origin-one-printers
Now let's move on to SAF.
SAF is a type of powderbed printing where a print head puts black dye on each layer of powder which causes that area to heat up and fuse when an infrared head passes over it, similar to MJF printing from HP. To learn more about SAF, click here.
(Don't confuse it with SLS, there's no laser involved, so there's no 'L'.)
Here's what it looks like on our part:
And here's how they 'stack up' for support:
Notice how our SAF engineer stacked three of the lattices on top of one another, with no real change in print time? If I had done that in FDM, I would have had a linear increase of THREE TIMES the print time and a LOT MORE support to remove (dangerously packed in between the stacked models as well).
But SAF seems perfectly suited for complex Voronoi lattices because the powder acts as a support everywhere all the time all at once, so not only do you not waste time GENERATING support in GrabCAD Print, you don't loose hours of your life REMOVING that support after the print:
I got SO jealous of our SAF Applications Engineer Max Dawes in the UK office when watching that clip, he did in 15 seconds what I had to spend 4 episodes of Better Call Saul to accomplish with needle-nose pliers! (They were good episodes, however.)
All of our current SAF printing takes place with the smooth but tough nylon material PA 11. Here's a chart showing how the nylon PA 11 compares to the FDM and Origin materials we just discussed above:
And that makes sense for a nylon material: medium strength, but low stiffness (probably meaning a good toughness when those tests are eventually done) and a surprisingly high HDT! If you want to learn more about PA11, click here.
After SAF printing, you can throw them into a DyeMansion glass media blasting machine to automatically remove any excess powder, and later dye them almost any color you want!
But there's really nothing to change when printing Voronoi lattices on SAF technology, our experts say:
If you wanted to learn more about how to use GrabCAD Print with SAF technology, including WHY to point your important customer-facing 'A-Face' down, read this previous tutorial the SAF guys helped me write: https://grabcad.com/tutorials/how-to-use-grabcad-print-for-saf-h350-printers
But, looking at the whole process from a distance, here are my final thoughts on printing Voronoi Lattices in different technologies:
Based on those print times, if I wanted to test something simple and rough, I'd probably print in FDM first, since that's the most wide-spread of the 3 technologies (at least in the offices I visit).
But if I wanted to get something done FAST, smooth enough that someone could actually WEAR it or USE it or SHOW it to a customer, I'd probably turn to Origin/DLP next. A very wide material selection and very smooth prints, compared to FDM.
And when I'm ready for full-scale production, I'd probably go to powder/SAF- it's the same smoothness as Origin, I can dye the final products almost any color I want, and I can get some Economies of SCALE- notice that the 7 hour printing time was for THREE copies of the part- and we didn't even get close to filling up the build volume!
But wait, there's more.
-
Step 9: Bonus Content: Field Driven Design in nTopology for 3D printing
You don't have to read this part.
If you ever want help designing your own complex Voronoi lattices for any type of FDM, resin or powder-based 3D printing, message me through the GrabCAD Community or at shuvom.ghose@stratasys.com, and I'll help, or find the right person who can.
But if you want to see what ELSE nTop might do to make your models awesome on your own, read this bonus content. Think of it like 'new game +'.
nTop deals a lot in 'fields'.
If you had a 3D spatial field that had 'higher value' at one end of space and 'lower value' at the other end, you could use that field to drive some parameter important to your model.
So I made a point in space near the thumb hole of my model, and the 'field' is just the distance away from that point:
But that 'field' is a number nTop can reference.
So I can use that 'field' to drive the THICKNESS of my Voronoi Structural Ribbing, making it go from 2 mm near the thumb hole to 10 mm at the edges:
Obviously 10 mm is not 170 mm, so how did we get the scaling of those rib thicknesses to match the distance from the point? With a VERY often used nTop command called "Ramp":
And so you can see that I just 'ramped' my field from distances to lattice thickness, based on how far away it is from the hole:
The crazy thing is, Ramp even works in the OPPOSITE direction, so I can have the ribs get thicker near the hole and fall away thinner instead:
I actually laughed out loud when I just typed the '10 mm' and '2 mm' numbers in the opposite order into the Ramp command and it just worked.
It's really refreshing to experience a truly 'programmatic' language like this, where nTop doesn't restrict you from doing things like that, just faithfully tries to figure out the math once you do!
This obviously opens up a whole RANGE of 3D printing possibilities.
Infill thickness driven by distance from an edge? Sure, no problem.
Infill thickness driven by a SIMULATION result? Yeah, nTop does that all day.
Lattice thickness or infill thickness driven by almost ANY EQUATION you can map onto a field? Yeah, it's all math, man. nTop don't care. Go wild.
No one can think of all the ways to use this type of function, but if you want some ideas, nTop has a blog post with some ideas here. And here.
There's also a great teaching video from nTop engineer Yuki Okada about 'field driven design' which I used to create the above examples- Worth a watch!
Another thing a lot of people want to do is take a logo of theirs and emboss or deboss it into their 3D printed body.
This is easy with text, harder with hand-drawn shapes. What are you going to do, CAD up all the lines in your curvy hand-drawn logo?
But you CAN convert that PNG of your logo into a field, similar to my point field above:
And just like the thickness change before, you can 'map' that field to your emboss/deboss numbers using a 'Ramp' function and 'Offset Body':
(PADT is a really capable Stratasys reseller in the Arizona/Utah region. I'm working with them to actually print the model with their logo on their SAF machine, if we get it done I'll update this tutorial here showing off the final results!)
Now, there are a lot of steps I left out, mainly on how to make the field 'point' in the right way to wrap around your curved body (lots of vector dot products) and you can see there is some clean up to do around the top of the logo, where the tips of the triangle stick out a little, but you get the general idea: logos become fields, which become math we can use to operate on our solid bodies inside nTop!
So finally, the question becomes: How you would ever FIND commands or workflows like this, if you didn't know where to start?
How do you LEARN this alchemy?
Well, there is a search bar at the top of the nTop command stack, and you COULD search there for commands, but look how many results I get when just typing "Voronoi":
Obviously you can take training from nTop engineers when you buy a license, just like any other engineering software.
And there is a growing number of youtube videos on how to use it, although not as many as more widespread software like SOLIDWORKS or Rhino.
But to figure out the logo workflow above, I had huge help from a man on the inside, engineer David Busacker who once worked at Stratasys and now works at nTop. David greatly helped me out with the sequence of vector dot products and even KNOWING that such a the workflow was possible, and that's the real key.
Just like software developers who share elegant open source snippets of code on Github, who freely answer each others' coding questions on Substack, and who show off what they've done in youtube videos, forums and Reddit, I think the real key is helping each other out.
If you do something amazing in nTop or 3D printing or Voronoi structures in general, document and share it in a public place, hopefully in a way that's not only flashy, but also so other engineers can follow your steps and recreate it on their own.
Using generative software to help us create designs so complex no human could ever have drawn them is the future. But only if we all document what worked and what didn't, so that our combined skill and knowledge only moves forward, not back. We're literally writing the text books of the future here.
That's what I've tried to start with this tutorial, definitely leave a comment if you want to see a certain area explored more. And ANYONE can always email me at shuvom.ghose@stratasys.com and I'll try to help you the best I can. Hopefully this helped make you a little more powerful- now go off and print great things!
