3D Print Things: Conquering Size Limits with a Python Jigsaw Generator

Jan 2025 – 12 min readFeatured: ★ Hackaday ★ Hacker News ★ Real Python Podcast

I’ve always been fascinated by automated workflows when creating anything. There’s a unique satisfaction in watching a machine take over the work, especially when combined with parametric design, which makes iteration and customization incredibly easy. My recent speaker project perfectly exemplifies this approach.

With that speaker project, I was pushing the boundaries of what I could comfortably 3D print in one piece without significant design splitting. Exploring large format 3D printers became a necessity, but these machines are often expensive and might not offer the specific capabilities I already had.

Then, I came across a video by Richard from RMC where he 3D printed an entire arcade machine using a network of smaller, more accessible printers. His process involved designing the model and then dividing it into macro layers, each further segmented into smaller parts with dovetail joints for assembly. This method proved remarkably effective.

Richard assembling the arcade machine on RMC. Lots of colours, great use of spare filament. It’s where I got the idea!

This sparked a crucial question: Could this process be automated?

Reflecting on my previous speaker design article, I briefly mentioned the idea of floor-standing speakers, casually overlooking the challenge of segmenting the print. However, if I narrowed the system’s focus to panel-based designs, like this speaker system, automating the segmentation seemed achievable.

Having already developed a system for nesting parts efficiently on print beds, I decided to expand its functionality. The goal was to enable it to split panels into jigsaw-like pieces. Dovetail joints seemed ideal for this, offering easy gluing and eliminating the need for extra hardware like dowels.

If successful, this approach would allow for dividing complex geometries into printable sections without significantly compromising the final product’s appearance.

The Dovetail Profile

Dovetail joints are a traditional woodworking technique renowned for both strength and aesthetic appeal. They are commonly used where robust and visually pleasing joinery is required. Dovetails can be crafted manually, with handheld routers (using jigs), or by CNC routers.

Their strength comes from the wedge effect, which tightens the joint when pulled apart. Tapered dovetails further enhance this, creating an even tighter fit during alignment. This is particularly beneficial for gluing, as it prevents the glue from being squeezed out.

Dovetail example (from wikipedia!)

I investigated existing dovetail implementations in OpenSCAD, but none fully met my specific requirements.

My aim was a design where plastic is subtracted only once, resulting in perfectly mating joints right from the print bed. This would simplify the design process, avoiding the need for intricate, overlapping negative spaces in the two parts.

This led me to consider a thin, shell-like, zig-zagging ribbon structure – ideally with a taper.

Through the magic of anachronism, this is what I had in mind

However, OpenSCAD, being based on Constructive Solid Geometry (CSG), isn’t ideally suited for creating thin shells, making this a somewhat challenging task.

Deriving the Geometry

The following images illustrate the step-by-step deconstruction of the dovetail profile. This process involved several iterations to refine the design, eliminate artifacts, and optimize performance.

Step 1: square tooth design, with half length shoulders using polygon(). Note that x-axis is half way up tooth.

Step 2: Chamfer edges with a ratio of 1:1.4 to allow locking

Step 3: Round internal and external edges with a quad offset(), intersection to remove the unwanted roundovers

Step 4: Subtract a negative offset of itself to form an outline

Step 5: Subtract the sacrificial tab

Step 6: Extrude the individual tooth as we enter 3D

Step 7: Scale the extrusion by the same ratio (1:1.4)

Step 8: Remove the sides which interfere with the mating teeth

Interestingly, Step 8 was initially attempted using intersection, but it severely impacted OpenSCAD’s performance, dropping rendering speed dramatically.

Step 9: Iterate to join several together

Initially, I didn’t remove the interfering edges, leading to hanging artifacts. This initially seemed like a bug until closer inspection of the 3D tooth revealed the issue.

Step 10: Subtract this from the work piece

Success! Note, the parts are not separable in OpenSCAD

The code below implements the described process, with annotations linking each step to the visual breakdown above. Remarkably, it’s only 68 lines of code!

| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | height = 20; size = height/4; ratio = 1.4; rounding = size/5; gap = 0.2; module tooth() intersection() { $fn=160; translate([0, gap/2]) // STEP 3: Quad offset // external offset(rounding) offset(-rounding) // internal offset(-rounding) offset(rounding) // adding rounding to sides to cancel radius when looping // STEP 1 polygon([ [-size - rounding, -size/2], // left shoulder [-size/2 * (2-ratio), -size/2], // left neck // STEP 2 (ratio) [-size*ratio/2, size/2], // left ear [size*ratio/2, size/2], // right ear [size/2 * (2-ratio), -size/2], // right neck [size + rounding, -size/2], // right shoulder [size + rounding, -size*2], // right bottom [-size - rounding, -size*2], // left bottom ]); // shave off the rounded bit of the shoulders translate([-size, -size*4]) square([size*2, size*5]); } module tooth_cut() difference() { // STEP 4 tooth(); offset(-gap) tooth(); // STEP 5 translate([-size*2, -size*5 - size/2 - gap/2, 0]) square([size*4, size*5]); } // this is done in 3D rather than 2D to allow for a taper -- this way the fit // tightens as the teeth are pushed in, and the glue is squeezed instead of // scraped module tooth_cut_3d() difference() { translate([size, 0, -1]) // STEP 6 & 7 linear_extrude(height, scale=ratio, convexity=3) tooth_cut(); // STEP 8 // difference is used to constrain the edges to prevent overlap // I tried intersection (to do it in one pass) but performance TANKED! translate([-size*2-0.01,-size, -1]) linear_extrude(height+2) square([size*2, size*2]); translate([size*2+0.01,-size, -1]) linear_extrude(height+2) square([size*2, size*2]); } // will get at least length module teeth_cut_3d(length) { n = ceil(length / (size*2))+2; real_length = n * size*2; // STEP 9 for (i=[0:n-1]) translate([i*size*2 - real_length/2, 0]) tooth_cut_3d(); } module dovetail_demo() difference() { linear_extrude(18) square([110, 60], center=true); // STEP 10 teeth_cut_3d(300); } dovetail_demo(); |

dovetail.scad Download

Test Prints

To determine the optimal parameters for the dovetail joint ratios, I conducted several test prints. I opted for smaller teeth, which minimized potential artifacts and seemed to provide a tighter fit.

First attempt: giant 1:1 teeth. Taper visible

1:2 teeth with edge artefacts

Small 1:4 teeth that seem best!

Richard’s 0.2mm interference fit proved to be the sweet spot, providing a slight play while ensuring ample space for glue.

Successful implementation after several iterations

Performance was optimized by limiting the number of faces ($fn=16) in the tooth code. This offered a good balance between smoothness and reduced stress concentration.

Z fighting (sparkles)

I had some initial concerns about Z-fighting occurring when joining parts. While typically I ensure parts slightly intersect to avoid this, it appeared visually acceptable, and I proceeded cautiously, hoping to avoid manifolding issues.

Edge Artifacts

Occasionally, the top of a tapered tooth might be suspended in mid-air, especially near design boundaries. This can lead to printing issues like spaghetti and missing sections in the final 3D printed thing.

Close up of hanging artefacts together with the scaled edges interfering (fixed since)

I realized that these artifacts could be detected and removed in post-processing. By identifying small, detached fragments not in contact with the print bed, the spaghetti issue could be mitigated. While holes might still occur, they could likely be addressed during the finishing stage.

Automating STL Splitting for 3D Prints

With functional in-place joints, the next step was automating the process to divide any design for printing on a standard-sized 3D printer bed.

Since this system is designed for panels, operation is primarily 2D, assuming mostly flat and rectangular parts.

Automation was approached by operating on STL files directly, largely outside of OpenSCAD. This makes the system compatible with models from any CAD software, expanding its versatility for various 3d Print Things.

Building upon existing part nesting software using rectpack and numpy-stl, the code was developed as follows:

Load the STL file and determine the model’s bounding box.
Rotate the model to align its aspect ratio with the printer bed, optionally orienting the longest dimension along the bed’s axis.
Calculate the necessary subdivisions on each axis to ensure parts fit within the print bed (accounting for tooth size).
Execute an OpenSCAD template to subtract dovetail teeth from the model, positioning each cut accurately via STL translation.
Split the resulting STLs into individual files using the slic3r CLI.
Remove any edge artifacts by identifying and eliminating small, detached objects.

Results of Automated Splitting

Refactoring the nesting code enabled seamless integration of the dovetail splitting functionality. However, initial runs were disappointing, taking four hours per operation and failing with errors like:

ERROR: CGAL error in CGALUtils::applyBinaryOperator difference: CGAL ERROR: assertion violation!
ERROR: The given mesh is not closed! Unable to convert to CGAL_Nef_Polyhedron

OpenSCAD’s reliance on the CGAL library, known for its slowness and potential to produce non-manifold meshes, was the likely culprit. My speaker design, suspected of generating non-manifold STLs due to OpenSCAD or code issues, seemed to trigger these errors.

Facing this roadblock, I explored OpenSCAD’s newly integrated geometry library, Manifold. This library promised significant speed and robustness improvements.

Switching to an unstable OpenSCAD version with the --backend=manifold flag proved transformative. The computation time plummeted to 223ms, a 64500x improvement!

Manifold’s increased memory usage and multi-threading capabilities required adjustments to my build scripts, which previously processed 16 parts simultaneously. However, after further refinement, the system performed as expected.

Below are the results of applying this process to the previous speaker design, reducing the bed size to 200x200mm – making it printable on a Prusa i3.

bed-1.png

bed-10.png

bed-11.png

bed-12.png

bed-13.png

bed-14.png

bed-15.png

bed-16.png

The original design, so you can imagine how the parts assemble.

bed-17.png

bed-2.png

bed-3.png

bed-4.png

bed-5.png

bed-6.png

bed-7.png

bed-8.png

bed-9.png

The system performed exceptionally well. The nesting algorithm effectively grouped split parts, reducing the number of print beds required, which in turn minimizes printing time and material. In one instance (bed 17), a part was further split to fit within a single bed.

Worryingly thin tooth that could cause print issues

Corners frequently exhibited worryingly thin teeth, which could cause printing problems. Knowing the dovetail joint intersection points, strategically skipping teeth in these areas could mitigate this issue – a refinement for future development.

turbojigsaw.py

The code is linked above. It requires slic3r, rectpack, openscad-nightly, and numpy-stl, with dovetail.scad placed in the lib/ subdirectory. Hacked from two separate files, it may require minor adjustments to run smoothly.

Conclusion

The selected dovetail profile is self-aligning and maximizes the glue bonding surface area. Alignment during assembly is straightforward, especially with a silicone mat to prevent unwanted adhesion.

This successful automation paves the way for realizing a floor-standing speaker design and other large 3D print things in the near future. Further steps include design validation and experimenting with various adhesives and finishes. Alternatively, this method could be applied to revamp my older MDF subwoofer project.

While a more case-specific implementation within the speaker design, with around 12 special cases, might have been possible, this automated approach offers greater versatility and elegance. Such a specific approach could also help avoid edge artifacts and allow for more precise joint placement in less detailed areas.

Future improvements could combine the best aspects of both approaches:

Variable part division locations for stronger, more practical joints.
Tooth skipping at joint intersections.
Tooth skipping near voids or edges.
Center-aligning teeth to middle axes.

Exploring trimesh could further enhance the system, potentially replacing numpy-stl and/or OpenSCAD, offering broader capabilities.

Based on past projects, I am confident that filled and sanded assembled parts will achieve a seamless finish.

The code is available for download in this post. If there is significant interest, I am happy to package it more formally. I’m eager to see how others might utilize or adapt this concept for their own 3D printing projects.

Thank you for reading! If you have any comments or enjoyed this article, please consider sharing or upvoting it on Hacker News, Twitter, Hackaday, Lobste.rs, Reddit and/or LinkedIn.

Please email me with any corrections or feedback.

Tags:

3d-printing manufacturing openscad python software

[