As-Continuous-As-Possible Extrusion Fabrication of Surface Models

Affected by the fluidity of materials, too small layer thickness would cause the layers to squeeze together. Such an over-stacking effect results in artifacts on the surface (see inset). While too large thickness results in under-stacking, the adjacent layers are not well bonded. We use $t_{min}$ and $t_{max}$ to represent the minimum and maximum layer thickness. For ceramic printing, we take $t_{min}=0.5mm$ and $t_{max}=2.5mm$. For FDM printing, $t_{min}=0.05mm$ and $t_{max}=0.7mm$. This range is used as a constraint when generating the curved layers.

In [Etienne et al., 2019], the collision constraint has been modeled as an inverted cone to forbid already printed parts from entering. A local slope angle constraint for the printing paths is extracted from the forbidden cone as $\theta_{max}=\min(\theta_{nozzle},\theta_{object})$ (see Figure 4 for the detailed formulation). Instead of regarding the printer as a pointed conical nozzle by overlooking the nozzle part’s flat outlet, we propose making this formulation more precise. We represent the nozzle as a combination of a cylinder and a truncated cone.

We make an interesting observation that the possible collision differently when going uphill and downhill. See Figure 4, when going uphill (left), since the point on the right side of the outlet (green dot) is closest to the layer printed below, it may collide first, which can be avoided by restricting the path slope angle as $\theta_{outlet}$. Conversely, when going downhill (right), the nozzle has to be raised by $t$ to avoid self-layer collision between the point on the right side of the outlet (green dot) and the current layer. There is no need to define any slope angle for the downhill case with the raising operation. Finally, set the upper bound of the path slope angle as $\theta_{max}=\min(\theta_{nozzle},\theta_{object},\theta_{outlet})$. Note that this is a local constraint. The global collision caused by the height of the printed model exceeding the nozzle length is not considered. The solution will be mentioned in section 5.

We involve restrictions on the support structures for surface models, as support structures degrade the surface quality [Hergel et al., 2019]. For surface models that are not self-supporting, we decouple the fabrication of the intact model and support structures, i.e., we pre-print the support structures and place them during the fabrication process. This requires that the support structures locate on the ground and form a height field volume related to the printing orientation, as the support structures placed on the model may induce too much weight for the printed shell to afford. For such models, we decompose them into multiple patches and assemble them after fabrication (an example is shown in Figure 21).

To build a simplified graph $G_{init}$ from $G_{depend}$, we traverse all nodes of $G_{depend}$, if there are two or more edges pointing to the same node or starting from the same node, delete these edges temporarily (crossed by dashed red lines in Figure 8(b)). Then compute the connected components. Each component acts as a node of $G_{init}$, which can be seen as a merged larger I-OPP by stacking. Such a merging process maintains the optimality, i.e., the sub-nodes of a $G_{init}$ node must belong to a single path of the optimal solution²²2This can be proved using proof by contradiction. If two adjacent sub-nodes belong to the two paths of an optimal solution, they must be terminal nodes of the paths. Obviously, the two paths can be further connected, which shows that the current path cover solution is not optimal. . The dependencies of $G_{init}$ are inherited from $G_{depend}$. As shown in Figure 8(c), the nodes are significantly reduced.

OPP nodes of $G_{init}$ can be further merged via stacking, as (1,2), (1,3,6), (3,5) in Figure 8(c). A merged flat OPP graph $G_{flat}$ of $G_{init}$ can be generated as a result of a path cover solution of $G_{init}$, where each path proposes a merged I-OPP. Each node of merged OPP comprises a sequence of I/II-OPPs (denoted as sub-OPPs), where the sequence edges indicate the printing order. Figure 9(a) shows a merged $G_{flat}$ with four merged I-OPPs based on the path cover solution {(1,2), (4), (3,6), (5)}. Note that the dependency relationships of $G_{init}$ are preserved. Such path cover solution can be generated from a specific Depth First Search (DFS) starting from the root nodes of $G_{init}$. Different from a general DFS, it may not explore as deep as possible to the unexplored node before backtracking. The search has to stop while a node’s dependent nodes have not been explored, such as (1,2,5) is not valid that (3) is not explored.

The path cover solution space of $G_{init}$ can be represented by a specific directed graph structure ($G_{solution}$), where the root node is set to an empty node (an additional virtual node), the non-root nodes indicate the corresponding merged I-OPPs of path cover solutions, the directed edges encode the printing order of merged I-OPPs. A path cover solution is presented as a finite sequence of directed edges and nodes of $G_{solution}$ starting from its root node, (see the sequence of $\{(1,2),(4),(3,6),(5)\}$ in Figure 9(b)).

To merge $G_{init}$ into the minimal number of I-OPPs, we aim to search for the shortest sequences while exploring $G_{solution}$. We propose two key techniques to speed up such exploration by pruning the solution space. First, starting from the root node of $G_{solution}$, we apply a beam search procedure with the branch and bound technique, to explore $G_{solution}$ level by level, where the beam search width is set to $W=10^{4}$ in our implementation. For each level of $G_{solution}$, we sort its candidate nodes by the number of included $G_{init}$’s nodes, which implies that we tend to pick the nodes of $G_{solution}$ including $G_{init}$’s nodes as many as possible. Note that nodes of $G_{solution}$ would point to the same node of next level if its sequence included $G_{init}$’s nodes remain the same, such as {(1,2), (4)} and {(1,4), (2)} both point to (3,6) and (3,5). Second, for generating candidate nodes of each beam search iteration, we use a greedy strategy in the path cover solution generation with DFS, that each traversal would explore as deep as possible, as the traversal (1,3) will not terminate at node (3) since node (6) can be added into (1,3,6) shown in Figure 8(c). We have proved the optimality of this strategy³³3In the traversal path process, if terminating the path when a node can be added, the node must be the starting point of another path. In the same way as the last proof, the number of paths of path cover, in this case, is at least 1 more than our strategy, so it is not optimal.. The proposed path cover exploration method would produce multiple optimal $G_{flat}$ with the least number of OPP nodes shown in Figure 9(c). The pseudo-code is presented in Appendix E.

OPP graphs are directed acyclic graphs (DAG). We propose an iteratively pair-wise merging procedure for a general DAG. For each iteration, randomly select an edge and try to merge the two related nodes with specific merging criteria to check whether they can be merged or not. If yes, update the graph by 1) erasing the edges of the two nodes, 2) merging a pair of nodes to one node and 3) connecting other related edges of the two nodes to the merged node. The terminal condition is that no pairs of nodes can be merged.

In our case, the directed edges of OPP graph indicate dependency relationships of OPPs. While merging a pair of nodes, one necessary criterion is to guarantee there are no multiple paths between the two nodes, since it will result in a deadlock of dependency after merging, shown in Figure 10(right). Another criterion is that the curving operation can be applied to the two OPPs (sub-OPP) nodes. The two merging processes are demonstrated in Figure 11(A$\thicksim$B) and (B$\thicksim$D). For each iteration of OPP Merging Process, we aim to merge two OPP nodes with the curving operation, which is taken as an inner loop of the OPP Merging Process (see a$\thicksim$c in Figure 11).

As for the inner loop, a DAG can be formulated from the two candidate merging OPP nodes: 1) take their sequences of sub-OPPs where each sub-OPP is a node and maintain the dependency edges of these sub-OPPs; 2) add back the associated dependency edges between the two sequences from $G_{init}$. While applying the pairwise merging strategy to the result DAG (Figure 11(a$\thicksim$c)), we only select edges that benefit merging the two sequences to a single sequence. Specifically, we label the nodes that have edges across the two sub-OPP sequences (two red edges shown in (a)), then select edges over such labeled nodes. For each pair of nodes, call curving operation to merge the two nodes (subsection 3.3). The pseudo-code is presented in Appendix E.

For different $G_{curved}$ of input, the final number of nodes after merging may be different. We randomly select one $G_{curved}$ with the least number of nodes since we only consider the OPP number criterion. Different $G_{curved}$ and order of merging OPPs by curving may result in curved layers with different distributions, in other words, different sub-OPP of the final III-OPP, as shown in the inset. Similarly, since the order of selecting nodes in two levels is random, we cannot guarantee the global optimal solution. Figure 23 shows an example, and more details are discussed in Appendix D.

Since there are only $segments$ in 2D models, they can be connected using Zig-zag pattern. For the two terminal points of a segment, if one is the entry point, the other will be the exit point. We select entry points for all $segments$, minimize the total length of the connection path between the entry and exit points of adjacent $segments$. Then we set a Euclidean distance threshold $D$ to determine whether two terminal points of two neighboring layers can be connected directly with a straight segment.

If the distance exceeds $D$, an extra path is added. See the inset, call the current terminal point in the current layer $P_{source}$, and the terminal point to be connected in the next layer $P_{target}$. Print along the current printed layer with $t_{min}$ layer thickness from $P_{source}$ to the position closest to $P_{target}$, and then print along straight line to $P_{target}$ (the orange path in the inset). The post path optimization in section 6 will improve the spatial distribution of the generated extra path.

With the known dependency relationships of these OPP paths, we apply a method as subsection 4.2 to produce a feasible fabrication order. Then, we plan travel moves between OPP paths by withdrawing the nozzle to a safe distance above the printed objects to avoid possible collisions (see Figure 1). Finally, a G-code file is generated to transfer the toolpath to the printer.

The top three models in Figure 17 and the four models in Figure 18 are all self-supporting. In the setting of Cura, we choose the Surface Mode, enable Spiralize Outer Contour and Retraction, and use the same nozzle movement speed as our method. It shows that our method outperforms Cura for shell models containing multiple contours or segments in both surface quality (fewer artifacts and slighter deformation) and fabrication efficiency (save 24%$\thicksim$48% of printing time). For example, as the Grail model printed with Cura (ceramic printing), a large number of transfer moves (1541) induce deformation (see the red circle in Figure 17). Such transfer moves would increase the forces on the printed part and may cause the collapse (see the yellow circle). In contrast, the ACAP toolpath for this model only has one transfer move in FDM, and even no transfer move in ceramic printing, and thus strengthens the model during fabrication and avoids these problems. Generally, our algorithm improves the printing efficiency more significantly for the models with multiple branches like the Julia vase or TPMS model. Moreover, we can see the benefit of curved layers, which reduces the number of OPPs by around 50%, and improves the staircase defect (see the upper part of the Crown model). The TPMS model has no curved layer, as the slope angle constraint restricts it.

For the models that require support structures, we pre-build the support structures and place them before printing the models. See the last three models in Figure 17. To make support structure easy to remove, we add a membrane on the surface of their contact before printing the model.

Generally, the quality of ceramic printing is more sensitive to toolpath continuity for surface models than FDM printing. Therefore, the clay results from the ACAP algorithm show significant superiority in the model quality over those from Cura. However, we can still observe some visible artifacts in the clay printouts, like over-extrusion at the zig-zag turning areas, seams at the junction of OPPs, and sagging at the concavity corner. The primary reason is that the DIW-based ceramic printing technique with clay is less mature than FDM with thermoplastics. The extrusion amount can hardly be precisely controlled due to material inertia. Moreover, there are many uncertainties during the fabrication process, such as material humidity, air pressure, and other coupled hardware and material problems.

We also remark a defect in curved layers. See Figure 19; we observe that the layer thickness is non-uniform in the outer boundary, appearing like the stair-case defect. The reason is that curved slicing layers are applied with adaptive layer thickness, and the material deforms in different behaviors when extruded in downhill or uphill directions. Such artifact might be improved via fine-tuning the material flow or the nozzle height, while highly demanding on three issues: stable properties of the clay material, accurate simulation of clay deformation, and precise control of the extrusion rate for clay in the printing platform.

The nozzle size, especially the nozzle length, also affects the number of OPPs, as the shorter nozzle indicates more possibilities for the collision between the model and the printing platform. See Figure 20, we test the nozzle length from 5mm to 30mm on the Julia vase model in three different sizes.

Table 2 shows the running time statistics with the number of nodes and edges of the OPP graph during each step of our ACAP algorithm. For most of the input models, our algorithm is extremely efficient in the generation of $G_{depend}$, $G_{init}$ and $G_{flat}$, since our algorithm does not involve any geometric computation in this phase, but only some graph operations. The only exception is the TPMS model (FDM), whose time of building $G_{flat}$ is much longer than that of other models, since it owns a large number of nodes and edges in $G_{init}$ (905 and 3295) with more iterations of beam search (44). The running time of OPP merging through curved layers varies mainly according to the number of $G_{flat}$ (#SO) and calls to CurviSlicer (#CU), where CurviSlicer is the bottleneck to speed up this step. Similarly, the time of layers connection ($\rm T_{l}$) is also time-consuming, which would apply CurviSlicer with the smooth term for each decomposed OPP patch. Besides, the toolpath optimization also takes a long time, worth improving.