TL;DR: OpenSCAD customers: gain a nightly make & enable fleet-csg in settings for 10x faster render (YMMV). Fabricate your devices more ambitious and document factors / successes right here!

Listing: opinions expressed listed right here are my hang.

• OpenSCAD = 3D CAD for developers
• CGAL Nef Polyhedra + GMP = so right it hurts (performance)
• Factual concatenating meshes, huh?
• CGAL’s diversified hidden gem: corefinement functions
• Mammoth outcomes already
• What about multithreading? Or skipping operations altogether? 🙃
• Rewriting trees to designate higher laziness and parallelizability
• What’s subsequent?
• Thanks!

OpenSCAD = 3D CAD for developers

OpenSCAD is a favored originate-provide fabricate instrument for 3D printing afficionados (and others). It’s no doubt a CAD instrument for programmers with a minimalist UI. A straightforward declarative programming language defines Positive Solid Geometry (CSG) operations worship unions, intersections, variations, that might per chance per chance additionally be parameterized with loops and variables.

Final year I grew fond of it to fabricate ever more advanced devices, however started operating into limitations: whereas interactive rendering was once exquisite, the closing rendering (rising the STL files to provide to the 3D printing slicer) was once horrendously slack. Sluggish sufficient to forestall me from doing what I needed, which was once to generate clear, diversified scalemail patterns:

However something was once off: my slicer instrument (Cura) was once in a situation to address 10×10 grids of my scalemail sample with out breaking a sweat, so why was once OpenSCAD so slack? So after investigating choices (wasn’t concerned to construct up locked in a obvious standard however proprietary CAD instrument with gargantuan a studying curve and high prices after its 1 year hobbyist licenses), I dove into OpenSCAD’s codebase and tried to worship what it was once as a lot as.

CGAL Nef Polyhedra + GMP = so right it hurts (performance)

Because it turns out, OpenSCAD is the use of the Computational Geometry Algorithms Library (CGAL) for its CSG operations. That amazing library permits for fully generic numeric kinds, and the style OpenSCAD is the use of is some voodoo magic “right” numeric style in accordance to the GNU Extra than one Precision Arithmetic Library (GMP).

Extra particularly, OpenSCAD is the use of 3D boolean operations on Nef Polyhedra, which offers extrely sturdy and beautiful outcomes, two welcome properties within the 3D printing hobby, however also is amazingly advanced and slack to trip (in particular with these right underlying amount abstractions).

Factual concatenating meshes, huh?

However no doubt I believed, if we beautiful have to assemble a grid of my interlocking patterns with none intersection, it’s beautiful a subject of concatenating the meshes, no special operations wanted.

Even for unions, many geometrical operations are required when overlaps / intersections require rising unusual factors, unusual edges, in expose to retain the topological soundness (manifoldness) of solids so they might perchance additionally be 3D-printed later, etc.

So I started exploring the “fleet-union” route (openscad#3636), in which I’d literally concatenated meshes if I might per chance per chance resolve that they are able to’t no doubt intersect with each and every diversified in accordance to their bounding boxes. This labored massive for some devices, however bumped into uncommon performance for others. Attempting for upright operands to union collectively is extreme for an excellent deal of devices, e.g. in a grid of overlapping tiles you can skip a tile to develop a fleet-union however two consecutive tiles would want a righteous union. That search neededs to be bounded (otherwise would be in quadratic time of # of operands; randomizing the operands would develop of labor well sufficient), the bounding field operations have to be lighter than the geometry itself (e.g. no longer right when unioning a swarm of cubes), many rather an excellent deal of issues wanted to be taken into fable.

I’ve paused this song for now however might per chance per chance stumble on it but again.

As about a of the extraordinarily fantastic and priceless OpenSCAD venture maintainers ❤️ pointed out on IRC, there was once one other possibility in inventory: faster operations the use of the Polygon Mesh Processing CGAL bundle (authored by sloriot@) and its “corefinement” functions. For that I needed to introduce Surface_mesh (after making an are trying w/ less ambiance fantastic Polyhedron_3) into OpenSCAD.

Corefinement works massive in some conditions, crashes (most continuously in unrecoverable systems) or politely fails in others (for occasion it dislikes non-manifold inputs, or inputs that share edges / vertices). So I stopped up rising a hybrid of Surface_mesh corefinement and Nef operations, reverting to the slack security of Nefs once we detect it’s likely unsafe to utilize corefinement (openscad#4087). My objectives was once to develop basically the most likely backwards compatibility with the general existing mannequin files accessible.

Mammoth outcomes already

The end result: 10x faster or more for my devices 🎉🎉🎉

And as a lot as 100x whenever you happen to construct up the aforementioned security assessments with the fleet-csg-belief-corefinement characteristic (openscad#4101.

You ought to restful take a look at it yourself (take hang of a nightly make; also with any luck we accumulate some legit benchmark suite rapidly, see discussion in openscad#3931).

What about multithreading? Or skipping operations altogether? 🙃

So I was once getting there, performance-vivid, however my devices had been restful too slack to no doubt scale up in complexity.

It was once rather glaring from the initiate that OpenSCAD’s rendering is mono-threaded, so I attempted multithreading it (as others had performed right here and there, which I didn’t know but) however came across it laborious to construct up upright speedups ensuing from the tree constructing of a total bunch devices. Dependencies limit the amount of parallel operations that will additionally be performed.

I then came across that unusual experimental lazy-union characteristic (openscad#350, in nightly builds since a year) which no doubt leaves the closing top-level union as a lot as the slicer to develop. That is in overall a gargantuan deal in case your mannequin is beautiful a top-level concatenation of very advanced devices, because it literally takes no time the least bit to (no longer) develop that top-level union.

BUT, as rapidly as modules are concerned, or for loops, or transforms, etc, lazy-union’s advantages are out of reach and OpenSCAD does manufacture right unions, which might per chance per chance additionally very well be 100x faster with fleet-csg, however restful no longer fleet sufficient to scale my scalemail to 100×100 grids 😀

Rewriting trees to designate higher laziness and parallelizability

So the diversified promising means is rewriting the CSG tree to something that offers more lazy-unioniable top-level operands, and besides will enhance the arity of each and every particular person CGS operation, in particular folk that will additionally be parallelized (e.g. union and intersection).

union() {
  a();
  translate([0, 0, 1])
    union() {
      coloration("red") sq.(1);
      coloration("inexperienced") sphere(1);
      translate([1, 0, 0]) sphere(1);
    }
}

The implications of knocking down this tree is to receive a top-level union that will additionally be skipped w/ lazy-unions:

a();
coloration("red") translate([0, 0, 1]) sq.(1);
coloration("inexperienced") translate([0, 0, 1]) sphere(1);
translate([1, 0, 1]) sphere(1);

So there you skedaddle: rewrite-tree (incubated on this department) fully drops the amount of time it takes to render this from 1min to 400ms (rewrite-tree + lazy-union). It might well well per chance receive taken 2sec with fleet-csg. It is probably going you’ll per chance per chance even skedaddle to N=10 (100 spheres) in 4 seconds, which wouldn’t total in cheap time with out the unusual strategies (you’d then in overall decrease $fn=50 or use diversified systems).

$fn=50;
for (i=[0:N-1]) translate([i,0,0])
  for (j=[0:N-1]) translate([0,j,0])
    sphere(d=1.1);

What’s subsequent?

Please gain a nightly make and (stress) take a look at these factors (enable within the settings, or in CLI with --enable=fleet-csg), file bugs (or merely document any success on the umbrella PR). That’s how originate-provide instrument gets better 🙏.

Roadmap to rising OpenSCAD lightning fleet:

• Introduce corefinement CSG operations in its build of Nef polyhedra (fleet-csg characteristic in Nightly builds, openscad#4087; preliminary discussions in openscad#3641)
• Belief corefinement to address more conditions (fleet-cst-belief-corefinement characteristic, openscad#4101). At possibility of accumulate more crashes right here.
• Compare non-lazy CGAL kernels. Within the intervening time need fleet-csg-right characteristic to lead obvious of some coarse conditions.
• Experiment with CGAL’s upcoming simplification routines (cgal#5461). Corefinement currently produces more triangles than Nefs, which would perchance designate some devices higher and even slower.
• Enable fleet-csg (and most likely fleet-csg-belief-corefinement) by default within the next OpenSCAD liberate unless blockers are came across.
• Introduce rewrite-tree characteristic to vastly designate higher conditions covered by lazy-union.
• Be obvious that unions and intersections are parallelized to some level, per chance the use of one amongst the prevailing experiments.

Thanks!

Mammoth ensuing from the devoted personnel of OpenSCAD maintainers for his or her never-ending persistence & toughen (special shoutouts to t-paul, thehans, redlizard, rcolyer and MichaelAtOz) and CGAL corefinement guru sloriot for providing the magic (and urged toughen) to designate the magic happen.

Oh and thank you for studying!

Please add any comments to this gist
(there are also train threads on reddit, hacker files and on the openscad mailing-list).

Practice ochafik@ on Twitter to practice my subsequent experiments!