1 Introduction
Advanced manufacturing processes dramatically increase the complexity of physically fabricable geometries. For example, a 3D printer can directly fabricate an intricate, high genus shape, so long as it fits in the machine’s build volume. In contrast, standard laser cutters have a much larger albeit twodimensional cutting bed. Unfortunately, these complementary strengths are not easily leveraged harmoniously in a single design. In particular, large threedimensional objects are not well suited for either process in isolation. Further complicating design, construction of fabricable parts is a nontrivial task, often requiring slow iterations between virtual design and physical prototyping. For example, a design that looks feasible, may turn out to have overlapping or corrupted geometry.
In response, we present the RodSteward system, a designtoassembly system for creating furniturescale structures composed of 3Dprinted joints and precisioncut rods (see Fig. RodSteward: A DesigntoAssembly System for Fabrication using 3DPrinted Joints and PrecisionCut Rods). This design space is especially interesting because nearly all geometric complexity is shifted onto the small joint shapes, harmonizing with the qualities of the 3D printer. Meanwhile, the long rods can be purchased en masse at any hardware store and diced up with any tool capable of simplebutprecise perpendicular cuts (e.g., a laser cutter, but also a handsaw and miter box). Sparse, wireframe designs are also a currently trendy modern furniture aesthetic.
The RodSteward system has three stages: 1) RSDesigner, a fabricationaware design interface; 2) part geometry realization and physical printing and cutting; and 3) RSAssembler, a guidedassembly interface. RSDesigner allows the user to edit a virtual structure while interactively maintaining an accurate visualization of the fabricated parts. Our emphasis on realtime feedback allows a user to finetune and evaluate designs onthefly. The interface will highlight and alert the user to potential problems with the design such as overlapping parts or structurally unstable designs. Complementing this interface, we propose a novel joint geometry construction algorithm, which generates solid, watertight and 3Dprintable joints given the user’s rodjoint network description. A subset of existing methods require manual intervention to generate the literal geometry of each joint, breaking the exploratory design loop. In contrast, our method belongs to the class of automatic methods with a tight design loop that allows the user to focus on the highlevel creative aspects of the overall design, rather than the geometry of each joint itself. With varying physical accuracy, some previous methods have simulated the structural stability of rodjoint structures. Our contributions complement this particular wellexplored feature, and we therefore leave incorporating this aspect as an incremental improvement to RodSteward. Instead, we focus on firstorder design issues such as rodintersections and balance.
Upon design completion, we automatically engrave each joint with a visible I.D. and send the parts to the 3Dprinter. For rods, we generate a cutting plan that packs the segments into a minimal number of standardsize rods, so all can be cut in a single, quick job (see Fig. 1). After fabricating the individual parts, RSAssembler visualizes the partial structure as the user places each part. The user presses a hotkey to advance and the guide suggests the next part to place and updates the visualization. Without the guided assembly interface, assembling these complex structures would reduce to solving a frustratingly difficult 3D puzzle.
We demonstrate the effectiveness of RodSteward as a designtoassembly system, by constructing structures (e.g., Fig. 2) that highlight the simplicity and generality of our system to accommodate nonmanifold edgenetworks, circular and polygonal rod profiles, acute angles between adjacent rods, and complex yet nonselfintersecting and balancing structures.
2 Related Work
In the past decades, designers, researchers and hobbyists alike have looked for ways to leverage the geometric complexity afforded by 3D printing with traditional or unconventional parts. We focus the discussion of previous works on those similar in terms of interface aspirations or methodologies. The main differences with our work are: our endtoend, designtoassembly system; the fabricationaware tight interactive design loop, and interactive guided assembly plan. To our knowledge, no such complete system exists.
2.1 Design and assembly
The humancomputer interaction and computer graphics communities have embraced computational fabrication and its evolution beyond classic computedaided design and manufacturing (see, e.g., [MBM15, UBM15, BKLZ17, LEM17]). We join this field of research in rejecting the idea that the existence of massproduction should preclude an individual’s opportunity to participate in the unique design and customization of everyday objects (e.g., see Fig. RodSteward: A DesigntoAssembly System for Fabrication using 3DPrinted Joints and PrecisionCut Rods).
We are especially interested in hybrid or heterogeneous systems that combine 3Dprinting with other materials to create larger objects. For example, Kovacs et al. [KSW17] build room and architecturalscale objects with 3Dprinted joints and recycled PET bottles. While their 3Dprinted geometry construction is also automatic, their trusses result from intersecting a 3D shape with a tetrahedral honeycomb, so joints are less general with fixed topology. Kovacs et al. [KIL18] incorporate actuation to create articulated structures, but the fixed joint configuration remains. In contrast to our designtoassembly system, the interface contributions of these methods stop at fabrication: the user is left to build a complex structure with many labeled parts and no explicit instructions. Unlike this and other tools that only focus on design and fabrication, we consider the endtoend system from design to assembly.
Leen et al. [LRL17] introduce a tangible, modular magnetbased interface for designing wireframe objects. This work complements ours and could provide input to our RSDesigner tool, although their sensor rods have upper and lower bounds on length and joints can only accommodated a fixed number of incident rods at bounded angles. Meanwhile, Agrawal et al. [AUK15] physically sketch very general, yet temporary 3D wireframe structures using a device that extrudes tubes of tape.
Mueller et al. [MIG14] break away from layerbylayer 3D printing to fabricate wireframe structures by extruding plastic in 3D. Wu et al. [WPGM16] and Huang et al. [HZH16] extend this idea to a larger class of wireframe surfaces using a 5DOF printer, while Huang et al. [HGM18] plan paths for wireframe prints. Peng et al. consider the design of such wireprint objects via a traditional virtual surface modeling tool [PWMG16] and later an augmented reality 3D drawing interface [PBW18]. These methods focus on wireframe representations of surfaces and the design constraints are largely governed by clearance around the printhead during toolpathing and structural concerns. No assembly is necessary, but structures are smaller and denser.
Recently, Chidambaram et al. [CZS19] introduce a design tool for wireframe objects constructed via 3Dprinted connectors and metal wires. While their tool provides design suggestions, their method does not detect infeasible designs due to overlapping rods and does not alert the user if their design will balance. Their tool computes a stress visualization, but neither complete description of the method nor accuracy validations are provided. In this design space, the (strong) wood undergoes bending and stress concentrates at the (significantly weaker) plastic joints. It is unclear whether the space frames of Chidambaram et al. are the appropriate model. Their method is also restricted both by a hard bound on the length of wires (3cm) and the angle between rods (35°) in order to safely construct 3Dprinted connectors by unioning sphere and cylinder geometries. Due to this strict minimum angle constraint, it would be impossible for their system to accommodate the designs in Figures RodSteward: A DesigntoAssembly System for Fabrication using 3DPrinted Joints and PrecisionCut Rods (16°), 2 (26°), 13 (22°), or 15 (30°). Instead, we propose a more general joint construction algorithm that accommodates arbitrary angles, sizes, thicknesses, tolerances and polygonal rod profiles. As a result, our design space is larger and less constraining to the user. Chidambaram et al. provide assembly guidance, but only in the form of connector/wire indices and a printed lookup table of rod lengths. Our RSAssembler interface suggests an assembly ordering guided by a focus+context visualization.
Dritsas et al. [DCS17] create a sequence of Grasshopper scripts to aid in the design of structures similar to our results. Given a desired rod diameter, they determine minimum angle of incident joints allowed by their scripts and prevent/reject designs that do not meet this criteria. The generated joints are not guaranteed to be solid models which may cause printer failures. The interactive design or assisted assembly problems are not considered, so the user must (presumably) assemble a collection of similar looking parts.
Magrisso et al. [MMZ18]
propose a userassisted process to generate 3Dprintable carpentry joinery. Their goal is different from ours. They seek to enhance traditional manual carpentry with advanced manufacturing of individual joints, without placing a strong emphasis on realtime feedback of a tight design loop for the overall object. This process creates intricate joineries. The design remains creative, but also relies on the user for noncreative tasks such as supervision of the heuristic when it fails and tuning parameters to recover a feasible design. Our, in comparison, modest joint generation is fully automatic. This allows the user to focus on the creative task of designing the overall object, facilitated by immediate feedback and accurate visualization. The user never concerned with the precise meshing or representation of the joint geometry, only the highlevel design of the structure. Tian et al.
[TSC18] create a library of CNCmillable joineries to create an interface for woodworking. These beautiful results utilize a different and complementary fabrication process and design space.We are inspired by the early interactive exploration work of Umetani et al. [UIM12]. Our contributions are complementary: their method considers loads on panelbased furniture, but does not consider intersections that would prevent construction during design exploration. Later, Garg et al. [GJG16] visualize collisions during choreography and arrangement of spacetime reconfigurables, but do not consider geometric modeling.
On a larger scale than ours, Yoshida et al. [YIO15] propose a design tool and additive manufacturing process to construct architecturescale structures out of unstructured chopsticks and glue. At this scale fused rods behave as a 3D texture or homogenized material for the shell of the structure. In contrast, we focus on designs where the rods dominate both the structure’s form and function.
2.2 Joint Geometry Construction
It is tempting to consider joint geometry generation as an instance of simple wireframe meshing, but standard and research methods for this subtly different problem do not apply to our scenario. For example, Blender’s Wiremesh Modifier is guaranteed to generate quadrilateral meshes which is convenient for CatmullClark subdivision and other postprocessing, but this method only takes as input edges of a surface mesh. Panotopoulou et al. [PRW19] extend this idea to arbitrary edgenetworks by connecting together variable diameter quadrilateral meshes along each input edge. Their method minimizes but does not remove the twisting of the mesh faces along the segment. Unfortunately, any amount of twist is problematic for noncircular profile rods (see Fig. 8).
Tonelli et al. [TPCS16] create structures from 3Dprinted joints and wooden rods. Their process is not fully automatic and they only consider the wireframe of a surface mesh specifically designed to avoid acute angles between edges. From visual inspection, the method is unlikely to generalize. Assembly is even more tedious without a guide like RSAssembler: the joints and rods have been implicitly optimized to have slightly different geometry. Their main example took roughly two days to assemble.
Many examples of 3Dprinted joints and connectors for furniturescale structures can be found online. For example, Gellért [Gel15] has gathered a library of modular 3Dprinted connectors for panels to create shelving. Cegar [Ceg14] constructs 3Dprinted joints to connect wooden rods at 0° and 90° angles. The startup DesignLibero has a series of furniture and light fixtures composed of wooden rods and (presumably customdesigned) 3Dprinted joints [Rut18]. Fried [Fri16] has posted a Grasshopper script to generate node geometry for connecting (presumably only) circular profile rods. We are inspired by these designs and hope that our reproducible technical description of joint geometry construction as well as our novel user interfaces encourage this direction of hybrid design.
3 FabricationAware Design Interface
Our investigation is driven by the goal of facilitating the design of rodjoint structures. Rodjoint structures afford a harmonious division of complexity. Complex geometry is delegated to the joints, fabricated by a 3D printer designed for such a task, while rods retain their intrinsic strength and require only perpendicular cuts. Introducing precision 3Dprinting into the design task significantly increases the development time: printing the joints for the guitar stand in Fig. RodSteward: A DesigntoAssembly System for Fabrication using 3DPrinted Joints and PrecisionCut Rods
required 10 hours and 10 more hours to remove dissolvable supports. We would like to reduce the reliance on timeconsuming 3Dprinting during design as well as reduce the probability of fabrication, structural, or assembly failure. To this end, we introduce a minimal set of virtual design tools. Discarding potential but unnecessary tools is just as important as retaining the most effective ones. For this reason, we have written our design tool as a standalone application rather than a plugin to a monolithic commercial CAD tool. For example, existing CAD tools do not deal with intersections well
[GJG16]; some tools will simply crash and others will throw an error.The invariant we will maintain in our design tool is a 3D rendering of the resulting rodjoint structure (see Fig. 2). Threedimensional joint geometries are rendered in white (i.e., 3Dprinted plastic) and rod geometries in brown (i.e., wood). We expose the following editing operations to the user:

translate, rotate, and scale selected node positions using a standard 3D manipulation widget,

connect selected joints with new rods,

split a selected rod by inserting a joint at the midpoint,

drag on any rod to directly manipulate rod diameter (),

drag on any joint to directly manipulate the joint wall thickness () or the socket length (), and

choose the number of sides of the polygonal rod profile (or choosing a circular profile).
See Fig. 3 and our accompanying video for interaction sessions demonstrating each editing interaction. After any edit, the joint and rod geometries are immediately updated. When manipulating the sizing parameters (,,), the new value is displayed next to the cursor during mouse dragging.
3.1 Detecting and highlighting problems
Not all edgenetworks and parameter combinations are fabricable. We introduce a set of tools to help the user detect potential problems during virtual design before wasting time trying to fabricate an impossible design. In the physical world, two rods cannot occupy the same space. In Section 4, we will carefully construct joint geometry to prevent such rodrod intersections from happening locally at joints. Rodrod intersections can also occur globally between rods that do not share any joints. We robustly detect rodrod intersections using the libigl geometry processing library [JP19] and immediately highlight problematic rods in red. We do not prevent the user from making invalid designs. It is often desirable to traverse through invalid states into a new valid state (see Fig. 4). Our realtime feedback allows the user to visually track the feasibility of the design during any edit.
The angles of rods incident on a joint and the rod/joint thickness parameters determine the ultimate geometry of a joint. If the joints become too large or the rods between them too small, the joint geometries will overlap, swallowing a rod (in the notation of the next section, if ). We immediately highlight such problematic joints in red, alerting the user of an inefficient or undesirable design (see Fig. 6).
We also help the user determine whether the current design will stand. If the center of mass projected onto the ground falls outside of the support polygon, the design is deemed unstable (see, e.g., [PWLSH13]), and we alert the user by highlighting the center of mass and support polygon red (see Fig. 6).
The effectiveness of our design tool hinges on the ability to efficiently and fully automatically generate general and fabricable joint geometries and rod lengths. We now turn our attention to constructing and then fabricating these geometries.
4 Geometry & Fabrication
The input to our geometry construction algorithm is a 3D edgenetwork, i.e., a graph embedded in , composed of a list of node positions for and a list of undirected edges as pairs where we use the equivalence relation .
In this technical section, we use subscript notation such that refers to a quantity associated with the undirected edge , whereas refers to a quantity associated with endpoint on the edge and in general . In most cases, the difference will also be clear from context.
The algorithm is controlled by a number of userdefined parameters (see Fig. 7, right): the radius of the rods, the number of sides on the polygonal crosssectional profile of the rods (without loss of generality, we will assume these polygons are regularly shaped), the thickness of the 3Dprinted joints encasing each node, the amount that joints overhang along incident rods, and the “engineering tolerance” (possibly negative for friction fitting) between the joints and rods.
The output of our method includes solid meshes representing the surfaces of the 3Dprintable joint geometry at each node and precise rod lengths to cut. As seen in Fig. 7, the physically realizable length of the rod of each edge will generally be less than the raw edge length (). Instead, the precise lengths will be implicitly determined by the geometry of the joints at either node.
4.1 3DPrintable Solid Joint Geometry
The geometry of the joint at each node will be an independent solid object, but we require that the outlets at either joint incident on an edge to be consistent so that polygonalcrosssection rod geometry can be rotated to fit either end Fig. 8.
A useful subroutine is to generate the primitive geometry of a solid mesh of a generalized cylinder with the profile of a sided polygon. This is accomplished by extruding a regular gon inscribed in the unit circle of the plane along the axis for one unit.
This unitcylinder mesh geometry can then be transformed to lie along any given edge. For each edge , we compute a 3D rotation aligning the
axis vector
to its unit edge vector :(1) 
where
is the identity matrix and
is the matrix representing crossproduct by the vector :(2) 
We could place rod geometry along each edge by composing this peredge rotation with anisotropic prescaling along the axis by the edge length and radially in the plane by the desired radius and a posttranslation to the edge tip position . As a peredge affine transformation:
(3) 
where is a rigid transformation placing the rod into the edgenetwork. However, this naïve rod geometry will result in messy intersections at each node (see Fig. 7, left). In the physical world, we can not allow the rods of multiple edges incident on a node to “share” the space at that node. Offsetting by a uniform amount (cf. [Har06]) works when is large relative to and the angles between incident rods are not very acute. The 3Dprinted joints of Tonelli et al. [TPCS16] use a fixed offset, but their results are limited to surface edgenetworks with modest angles. For arbitrary edgenetworks, acute angles are common. If is too small relative to , overlaps will occur even for obtuse angles (see Fig. 7, center). If is too large, joints become bulky (everywhere) and may even (unnecessarily) envelope small edges.
We could remove the rodintersection volumes (e.g., the red regions in Fig. 7) from the rod geometries, but this would require nontrivial shaving or whittling of the rods. Instead, we move all complex geometry to the 3Dprinted joints and use simple straight perpendicular cuts on offtheshelf rods.
To this end, we compute pernodeedge offsets, where is the offset at node along the incident edge . The offsets at either end of an edge will in general be different (i.e., ). We would like values that: 1) are as small as possible and 2) guarantee that rods will not overlap. We can compute a safe offset by considering the minimum angle formed by edge and all other edges with :
(4)  
or equivalently the largest dotproduct  
(5) 
In general, for a node the smallest angles along different incident edges will not be the same (i.e., ). Given the rod radius and engineering tolerance , a safe offset is the solution to a trigonometry problem solved using the tangent halfangle formula:
(6) 
As this formula confirms, the offset tends toward infinity as the angle tends toward zero (and tends toward one).
Armed with offsets that guarantee the absence of rod intersections at joints, we can now generate solid joint geometry. We start by considering every edge . We generate unitcylinder mesh and scale it radially by and axially by . We then place two copies offset axially by and , respectively. Both are finally transformed into place by . All together, the tip and tail pieces are transformed, respectively, by:
(7)  
and  
(8) 
We denote the transformed solid models as and respectively. Though strictly not necessary to generate a solid joint, the in the axial scaling ensures a thick “cap” at each end of a rod. For each pair of transformed cylinders, we keep track of the mesh vertices of the cylinder model that end up at either end of the edge. That is, those with projected distance and to the tip and tail nodes, respectively. We call these vertexsets and , respectively. Due to the procedural generation and transformation of the cylinder model, this bookkeeping is purely combinatorial and does not require measuring distances after transforming each cylinder model.
Now we consider each node of the input edgenetwork. Like Hart’s method [Har06], we compute the convex hull of the node position and all vertexsets from incident edges . While this convex hull is guaranteed to have at least a twodimensional intersection with each of the incident cylinder models, it is not true (cf. [Har06]) that faces of the cylinder meshes will always appear as faces of the convex hull: some vertices of may be strictly inside the convex hull. We merge the hull model and the transformed cylinders of each incident edge by computing their exact mesh union via [ZGZJ16]. We denote the solid result of this union .
As a side effect of this process, we have determined that the precise length to cut the rod at each edge is the full edgelength minus the safe offsets computed at either end:
(9) 
For each edge , we generate unit edgecylinder mesh and scale it radially by and axially by . We then align this geometry with the offsets and transform it into place by by . All together, the transformation of the unitcylinder peredge is:
(10) 
We denote the transformed model at each edge by .
To complete our joint geometry, we consider each node again. We compute the exact solid difference of the joint geometry and the geometry of all incident edges . The result of this Boolean operation is the final solid joint geometry
(11) 
The mesh boolean operations resulting in and then are necessary to create a solid mesh. During interaction with our fabricationaware interface, the user is unaware that boolean operations are happily skipped as they do not affect the visual appearance.
4.2 3D Printing
Joint geometries are 3D printed using heuristic to pick a printing direction that minimizes support material placed inside the cavities at each socket (the most difficult to dissolve/remove). We compute the rotation that aligns the average edgevector with the printing extrusion direction (similar to Equation (1)). We use existing software (GrabCADPrint or Simplify3D) to pack the rotated 3D geometries into the smallest number of build volumes.
Each joint is automatically engraved with a twodigit identification number. This is achieved fully automatically. We start by oversampling the joint geometry at 10,000 uniformly random locations. We estimate curvature at each sample by taking the distanceweighted average of dihedral angles between the
nearest neighbors. We compute ambient occlusion at each sample with respect to the original geometry. We select the sample with the smallest sum of these two values and set the engraving’s radial extent to the distance to furthest of the sample’s neighbors. Text geometry with a thickness of is placed accordingly and subtracted from the joint geometry via [ZGZJ16] (see Fig. 9). The curvature and occlusion term encourages the engraving to be centered on a flat and visible region, respectively. This simple method was surprisingly effective. The label visibility allows RSAssembler to better guide the assembly described in the next section. It would be interesting to extend our labeling and print orientation heuristics to consider perceptual preference [ZLP15].Rods
In theory, any cutting method could be used to cut the rods (e.g., a traditional hand saw and miter box). However, often each joint has a unique length and the setup/measuring time of each cut starts to dominate for manual methods when the number of rods is large. Instead, we use a laser cutter to precisely cut all rods (or as many will fit into the machine at once) simultaneously. To maximize the efficiency of this process, we solve a onedimensional “binpacking”. That is, given a set of desired lengths to cut and raw factory uncut rods of factorylength (e.g., ), we find the assignment of cuts to uncut rods that minimizes waste and uses the fewest uncut rods (see Fig. 1). We implemented a “firstfit” algorithm with multiple random orderings and taking the best packing (the optimal fit, while NPhard to compute, will correspond to the firstfit result of some ordering [Lew09]). We use bin sizes of , where
is a padding amount (e.g.,
) to account for rough “factory” cuts at either end of the rod. The optimized cuts are translated into line segments of a .svg file that is sent to the laser cutter to be cut in a single run (see Fig. 1).We experimented with using the lasercutter to mark each rod during cutting in the hopes that this helps assembly. We found this to be unnecessary and, in fact, confusing. Instead, it was much faster to simply presort all of the cut rods by length and have a ruler/calipers nearby to select the desired rod.
5 Guided Assembly Interface
After physical fabrication, the design is reduced to a large number of 3D printed of joints and lasercut rods. For complex designs (e.g., the wolf head in Fig. 2), there are many similar looking joints and similar length rods. Incorrect placement of a rod is often not a problem as this length error will diffuse through the design. In stark contrast, incorrect placement of a joint leads to an angle error that grows linearly with distance and can cause a Dominoeffect of misalignment, infesting the entire design. To help the user avoid such assembly disasters, we propose a guided assembly interface.
The user starts by organizing the 3Dprinted joints (e.g., sorted by engraved id) and lasercut rods (e.g., sorted by length). On a nearby screen (e.g., currently our app runs on a MacBook, but could be ported to a tablet/phone), our guided assembly tool shows a 3D visualization of the design. The user can manipulate the camera parameters to view the design from any direction. After placing a rod or joint into position, the user hits a hotkey and the interface proceeds to the next suggested part to place.
Our guided assembly interface exercises focus+context [CKB08] (see Fig. 10): the current part to be placed is rendered in full color matching the physical counterpart (e.g., white for 3D printed joints and brown for wooden rods). Alreadyplaced parts are shown to provide context but recessed out of focus by shifting their color toward the (nonwhite) background color (e.g., teal). Yettobeplaced parts are abstracted as dots (joints) and line segments (rods). When the user signals that the current part has been placed, the 3D camera smoothly transitions to focus on the next part. That part is placed at the center of the screen and viewed at a distance so that all connected parts will fit into view when rotating the camera. For joints, the id number is show in a large font and the geometry (with engraving) is shown in a highcontrast rendering style to assist in matching the correct orientation (see Fig. 11). For symmetric joints, the engraved ID replicated in the RSAssembler display serves as a further registration mark. For rods, the length is displayed. See the accompanying video for a full guided assembly sequence.
Random assembly order would require significant context switching, both visually and physically. In addition, we found that is much more difficult to merge multiple sub parts than to add pieces onebyone. We experimented with various assembly order heuristics breadthfirst, rod length priorities, etc.), and ultimately found that a depthfirst traversal of the nodes in the edgenetwork works best. This strategy is guaranteed to produce a complete ordering, regardless of the size of the input. After placing a joint, the tool suggests each notyetplaced incident rod and then proceeds to the next notyetplaced adjacent joint. This ensures that the set of alreadyplaced parts is always connected and that the user often adds a new joint adjacent to the last added joint. In our experiments, structural stability of the partially assembled objects was not an issue, though as a future improvement this could be taken into account in the ordering (or even the possibility of adding temporary assemblyonly rods).
6 Results & Discussion
We 3D print the joints in our results using a Stratasys F170 in ABS Ivory plastic with dissolvable QSR support material. We laser cut our rods using a Trotec Speedy400 Flexx, which has a 1m×0.6m build plate. We use a variety of different rod materials purchased from a local hardware store: 6.35mm and 12.7mm diameter round hardwood dowels and 10.5mm² squareprofile wooden molding. The bottleneck in our endtoend designtoassembly system is by far the 3Dprinting and supportmaterial dissolution. Our slow 3Dprinter took more than 10 hours for most examples (1020 joints) and automatic supportmaterialremoving bathing took nearly as long. Fortunately, the entire 3Dprinting process is fully automatic (aside from moving parts from the printer to the bath). Using a “comb” jig to hold rods in place, cutting takes a few minutes. Assembly itself lasted under 45 minutes for all examples included in this paper: the wolf head in Fig. 2 taking longest with 28 joints and 52 rods.
We printed a small board containing sample sockets of varying engineering tolerances to determine good values for each rod radius and profile we used. This way we avoid printing joints that ultimately do not friction fit our rods (due to inaccuracies of either part). Tight friction fit joints allow us to avoid the use of tools
or screws during assembly. A locking mechanism and loosefit joints would be an interesting alternative.
The rodrod intersection testing allows designers to create structures with closely packed but not intersecting rods. In Fig. 12, the triangular prism shape was twist just until a collision occurred. Indeed, the assembled rods are nearly touching. Finding designs like this without a virtual realtime feedback interface like RSDesigner would be tedious and difficult.
An interesting design feature that serendipitously emerged from exploring in RSDesigner is that when scaling the node positions isotropically, the joint geometry remains identical: only the rods shrink/grow uniformly. This informs us that the same 3D printed joints can be used to create different scales of the same object: just replace the rods. We realized this feature in the lamp design in Fig. 13. A 1.4mtall lamp is first constructed, then all rods are cut in half and the lamp is reassembled as a 0.7mtall lamp.
We do not perform finiteelement analysis or optimize the design for structural stability beyond balance. Nonetheless the structures we create are sturdy, inheriting the strength of the wooden rods. In Fig. 14, we demonstrate a minimalist coffeetable design. This table is now in regular use at an office environment.
Disassembled, our structures are very compact (see Fig. RodSteward: A DesigntoAssembly System for Fabrication using 3DPrinted Joints and PrecisionCut Rods). Further, rods can be cut from standardsize dowels. Transporting a design could be as simple as shipping the joints and cutting rods on site.
Although circularprofile dowels are the most common and cheapest rods purchased at a hardware store, our entire system supports polygonal profile rods. In Fig. 15, a decorative bowl is designed using squareprofile molding for rods.
Unlike cheap, massmanufactured guitar stand, the unique design shown in Fig. RodSteward: A DesigntoAssembly System for Fabrication using 3DPrinted Joints and PrecisionCut Rods represents an aesthetic discovered by the user during modeling. The interface tools and onthefly evaluation of RSDesigner allow a user to fine tune a design in a tight loop.
7 Limitations & Future Work
Our designtoassembly workflow is not without limitations. We focused on mainly furniturescale results; although our tools will function correctly at any scale, the size of the structure is bound on the small end by the precision of the 3D printer and on the end by the length of the largest rod. We have also left various incremental improvements to design space as future work: e.g., nonregular convex polygon profiles, varying the rod radius across edges, varying thickness across joints, adding point loads to adjust the centerofmass. We are intrigued by the idea of adding finescale decorative patterns [STG16] or Voronoi duals [MMZ18] to our joint geometries. Very large or volumefilling designs (e.g., trusses) might raise performance concerns and require a dynamic boundingvolume hierarchy (cf. [GJG16]) for intersection testing etc. Our assemblies only required a single person guided by RSAssembler. We forgo a formal user study to confirm that guided assembly is better than having no assembly instructions [KSW17] or a static plan [TPCS16]. It would be interesting to use crowds or robots to build architectural scale structures à la Lafreniere et al. [LGA16].
If we idealize the joints and rods as perfectly rigid objects, then all our results are mathematically impossible to assemble. We are reliant on compliance. For our sparse, 1D structures reachability was not a major concern (cf. panelbased structures, [UIM12]).
The full power of the laser cutter has not truly been leveraged. We use the laser cutter out of availability (we have one), convenience (easier than manually cutting), and efficiency (faster, too). For the results presented here a robotic rod cutter might be more appropriate. In future work, it would be interesting to further exploit at least the twodimensional capabilities of the laser cutting in conjunction with the interfaces presented here.
While our lamps and coffee tables can withstand light external loads, larger furniture or structural shapes would require consideration of its use and placement its environment [UIM12, WOM17]. In future work, we would like to consider structural properties of joints [MIJ14] and directly incorporate loads from nontrivial contact and friction with external objects into our design tool (i.e., beyond the point loads of [UIM12]). We have already entertained interest from architects to adapt our joint generation for architecturalscale objects (see, e.g., Fig. 16). We are excited by the recent work of Yoshida et al. [YLI19], who build structures out of found tree branches. Curved or arbitrarily shaped rods could be another direction for future research.
References
 [AGWF15] Annett M., Grossman T., Wigdor D. J., Fitzmaurice G. W.: Moveablemaker: Facilitating the design, generation, and assembly of moveable papercraft. In Proc. UIST (2015).
 [AUK15] Agrawal H., Umapathi U., Kovacs R., Frohnhofen J., Chen H.T., Mueller S., Baudisch P.: Protopiper: Physically sketching roomsized objects at actual scale. In Proc. UIST (2015).
 [BKLZ17] Benes B., Kasik D. J., Li W., Zhang H.: Computational design and fabrication. IEEE CG&A (2017).
 [Ceg14] Cegar I.: 3d printed joints, 2014. URL: www.iaacblog.com/programs/3dprintedjoints2/.
 [CKB08] Cockburn A., Karlson A. K., Bederson B. B.: A review of overview+detail, zooming, and focus+context interfaces. ACM Comput. Surv. (2008).
 [CZS19] Chidambaram S., Zhang Y., Sundararajan V., Elmqvist N., , Ramani K.: Shape structuralizer: Design, fabrication, and userdriven iterative refinement of 3d mesh models. In Proc. CHI (2019).
 [DCS17] Dritsas S., Chen L., Sass L.: Small 3d printers / large scale artifacts: Computation for automated spatial lattice designtofabrication with low cost linear elements and 3d printed nodes. Int. Conf. of the Ass. for Comp.Aided Arch. Design Research in Asia (2017).
 [Fri16] Fried C.: Node generator, 2016. URL: www.grasshopper3d.com/forum/topics/nodegenetor.
 [Gel15] Gellért O.: Print to build: Joint collection for variable space structures, 2015. URL: www.behance.net/gallery/27812109/PrintToBuild3Dprintedjointcollection.
 [GJG16] Garg A., Jacobson A., Grinspun E.: Computational design of reconfigurables. ACM TOG (2016).
 [Har06] Hart G. W.: Sculptural forms from hyperbolic tessellations. In IEEE International Conference on Shape Modeling and Applications (2006).
 [HAW16] Harquail N., Allen M., Whiting E.: Foldlings: A tool for interactive popup card design. In Proc. GraDiFab (2016).
 [HGM18] Huang Y., Garrett C. R., Mueller C. T.: Automated sequence and motion planning for robotic spatial extrusion of 3d trusses. Construction Robotics (2018).
 [HZH16] Huang Y., Zhang J., Hu X., Song G., Liu Z., Yu L., Liu L.: Framefab: Robotic fabrication of frame shapes. ACM TOG (2016).
 [JP19] Jacobson A., Panozzo D., et al.: libigl: A simple C++ geometry processing library, 2019. libigl.github.io/libigl/.
 [KIL18] Kovacs R., Ion A., Lopes P., Oesterreich T., Filter J., Otto P., Arndt T., Ring N., Witte M., Synytsia A., Baudisch P.: Trussformer: 3d printing large kinetic structures. In Proc. CHI (2018).
 [KSW17] Kovacs R., Seufert A., Wall L., Chen H.T., Meinel F., Müller W., You S., Brehm M., Striebel J., Kommana Y., Popiak A., Bläsius T., Baudisch P.: Trussfab: Fabricating sturdy largescale structures on desktop 3d printers. In Proc. CHI (2017).
 [LEM17] Livesu M., Ellero S., Mart\́mathbf{i}nez J., Lefebvre S., Attene M.: From 3d models to 3d prints: An overview of the processing pipeline. Comp. Graph. Forum (2017).
 [Lew09] Lewis R.: A generalpurpose hillclimbing method for order independent minimum grouping problems: A case study in graph colouring and bin packing. Computers & OR (2009).
 [LGA16] Lafreniere B., Grossman T., Anderson F., Matejka J., Kerrick H., Nagy D., Vasey L., Atherton E., Beirne N., Coelho M. H., Cote N., Li S., Nogueira A., Nguyen L., Schwinn T., Stoddart J., Thomasson D., Wang R., White T., Benjamin D., Conti M., Menges A., Fitzmaurice G.: Crowdsourced fabrication. In Proc. UIST (2016).
 [LRL17] Leen D., Ramakers R., Luyten K.: Strutmodeling: A lowfidelity construction kit to iteratively model, test, and adapt 3d objects. In Proc. UIST (2017).
 [MBM15] Mueller S., Beyer D., Mohr T., Gurevich S., Teibrich A., Pfistere L., Guenther K., Frohnhofen J., Chen H.T., Baudisch P., Im S., Guimbretière F.: Lowfidelity fabrication: Speeding up design iteration of 3d objects. In Proc. CHI (2015).
 [MIG14] Mueller S., Im S., Gurevich S., Teibrich A., Pfisterer L., Guimbretière F., Baudisch P.: Wireprint: 3d printed previews for fast prototyping. In Proc. UIST (2014).
 [MIJ14] Mueller C. T., Irani A., Jenett B. E.: Additive manufacturing of structural prototypes for conceptual design. In Proc. Int. Ass. of Shell and Spatial Structures (2014).
 [MMZ18] Magrisso S., Mizrahi M., Zoran A.: Digital joinery for hybrid carpentry. In Proc. CHI (2018).
 [PBW18] Peng H., Briggs J., Wang C.Y., Guo K., Kider J., Mueller S., Baudisch P., Guimbretière F.: Roma: Interactive fabrication with augmented reality and a robotic 3d printer. In Proc. CHI (2018).
 [PRW19] Panotopoulou A., Ross E., Welker K., Hubert E., Morin G.: Scaffolding a skeleton. Association for Women in Mathematics (2019).
 [PWLSH13] Prévost R., Whiting E., Lefebvre S., SorkineHornung O.: Make It Stand: Balancing shapes for 3D fabrication. ACM TOG (2013).
 [PWMG16] Peng H., Wu R., Marschner S., Guimbretière F.: Onthefly print: Incremental printing while modelling. In Proc. CHI (2016).
 [Rut18] Rutilo L.: New family of hybrid design products created with 3d printed joints by italian startup designlibero, 2018.
 [STG16] Schumacher C., Thomaszewski B., Gross M. H.: Stenciling: Designing structurallysound surfaces with decorative patterns. Comp. Graph. Forum (2016).
 [TPCS16] Tonelli D., Pietroni N., Cignoni P., Scopigno R.: Design and fabrication of gridshells mockups. In Smart Tools and Apps for Graphics (2016).
 [TSC18] Tian R., Sterman S., Chiou E., Warner J., Paulos E.: Matchsticks: Woodworking through improvisational digital fabrication. In Proc. CHI (2018).
 [UBM15] Umetani N., Bickel B., Matusik W.: Computational tools for 3d printing. In ACM SIGGRAPH Courses (2015).
 [UIM12] Umetani N., Igarashi T., Mitra N. J.: Guided exploration of physically valid shapes for furniture design. ACM TOG (2012).
 [WOM17] Whiting E., Ouf N., Makatura L., Mousas C., Shu Z., Kavan L.: Environmentscale fabrication: Replicating outdoor climbing experiences. In Proc. CHI (2017).
 [WPGM16] Wu R., Peng H., Guimbretière F., Marschner S.: Printing arbitrary meshes with a 5dof wireframe printer. ACM TOG (2016).
 [YIO15] Yoshida H., Igarashi T., Obuchi Y., Takami Y., Sato J., Araki M., Miki M., Nagata K., Sakai K., Igarashi S.: Architecturescale humanassisted additive manufacturing. ACM TOG (2015).
 [YLI19] Yoshida H., Larsson M., Igarashi T.: Upcycling tree branches as architectural elements through collaborative design and fabrication. In Proc. TEI (2019).
 [ZGZJ16] Zhou Q., Grinspun E., Zorin D., Jacobson A.: Mesh arrangements for solid geometry. ACM TOG (2016).
 [Zho19] Zhou Q.: Pymesh, 2019. URL: pymesh.readthedocs.io.
 [ZLP15] Zhang X., Le X., Panotopoulou A., Whiting E., Wang C. C. L.: Perceptual models of preference in 3d printing direction. ACM TOG (2015).
Comments
There are no comments yet.