Issue 
Mechanics & Industry
Volume 25, 2024



Article Number  26  
Number of page(s)  11  
DOI  https://doi.org/10.1051/meca/2024019  
Published online  21 October 2024 
Original Article
A direct slicing method for optimized lattice structures
Univ. Grenoble Alpes, CNRS, Grenoble Institute of Engineering Univ. Grenoble Alpes, GSCOP, 38000 Grenoble, France
^{*} email: gilles.foucault@univgrenoblealpes.fr
Received:
19
October
2023
Accepted:
11
July
2024
Previous research show that conventional CAD BRep methods are highly inefficient to design large lattice structures composed of several thousands of geometric primitives describing struts [2,3]. This paper aims at proposing a method for slicing directly a lattice structure represented as a skeleton: a set of struts connecting nodes, where radius can be constant (cylinder) or linear (cones). The contribution of this method is twofold (1) efficiency: the CAD BRep representation is replaced with the skeleton representation which is robust and requires very low resources to be generated. (2) Accuracy: The method generates the explicit and exact geometry of layers with analytic curves, enabling the export into layers with polygons having an arbitrary accuracy.
Key words: Additive manufacturing / slicing / lattice structures / Digital Chain
© G. Foucault et al., Published by EDP Sciences, 2024
This is an Open Access article distributed under the terms of the Creative Commons Attribution License (https://creativecommons.org/licenses/by/4.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.
1 Introduction
Using additive manufacturing technologies, complex geometrical entities, particularly lattice structures, can be created [1]. They enable significant weight reduction in products [1]. The use of lattice structures can therefore be strategic in lightweight applications. However, they are rarely used today. Indeed Conventional CAD BRep methods are highly inefficient to design large lattice structures composed of several thousands of geometric primitives describing struts [2,3]. This type of representation is necessary in conventional parts for their visualization and finite element analysis (FEA) using 3D elements. However, this approach becomes computationally expensive for lattice structures due to their intricate nature. Thankfully, FEA can analyze these structures using beam elements instead of full volume models. Beam element simulations are significantly faster and sufficiently accurate for structures with less than 5% density [1]. Therefore, creating a complete volume model becomes unnecessary for analyzing lattice structures.
The slicing process converts the 3D shape into 2D horizontal layers of material to be deposited. The layers are then transferred to the additive manufacturing machine which generates its own build instructions.
In the current practice, the 3D shape model is created using a CAD modeler, and converted into an intermediate STL format which approximates the model with a triangulation [4–6]. The slicer process intersects the STL file with successive layers' planes to generate 2D slices. However, building the CAD model of lattice structures composed of a large number of struts is resource consuming due to the large number of surfaces [2,7].
Several works proposed improvement in the lattice structure model creation.
One can classify these approaches as following:
Triangulation approaches which generate a triangulation from a lattice truss representation.
Direct slicing methods which generate layers' 2D geometry directly from a lattice truss representation.
The slicing step can then be performed using algorithms such as Slic3r proposed in OpenSource [8]. First, a list of Z coordinates containing the height of each slice is generated. Several slicing processes are executed in parallel at different heights. The slicing process consists in computing the intersection lines between STL triangles and the slicing plane. Pair of lines belonging to adjacent triangles are connected at their common vertex, hence forming a linevertex adjacency graph. The final slicing step consists in forming the boundary loops of the slice by extracting cycles in the adjacency graph.
Marching Cubes Method (MCM) [9] tends to be more and more used to triangulate lattice structures for additive manufacturing. This technique consists in using voxelization of the 3D space around an object as well as a scalar distance field defined on each node of the voxel grid. Then, it uses simple rules to tessellate the wanted isovalue of the distance field. The distance field can be deduced from a skeleton. This method generates a large number of triangles which are usually of irregular geometric quality throughout the mesh. This is due to the fact that the number of triangles and their shape quality are directly linked to the size of the voxelization grid as well as to the orientation of the voxel grid relatively to the object. This is a strong limitation when considering lattice structures made of beams with widely varying directions.
The triangulation approach proposed in [10] generates the triangulation on each cylinders of every beam of the skeleton. A special Boolean operator moves vertices located in the interior of the lattice along their underlying cylindrical surface to reach the intersection curve with the closest adjacent cylinder. This method results in a watertight and manifold triangulation, while minimizing the number of triangles and respecting a chordal error limit. However, the method would be complex to extend to lattice structures featuring conical struts, adjacent struts featuring different sizes representing graded architecture materials.
More recently, Savio [11] used mesh subdivision techniques to triangulate lattice structures by generating on each strut two truncated square pyramids with respect to a predefined strut size. Each truncated pyramid is composed of 4 quadrangles for the side faces. The process ends with the CatmullClark mesh subdivision, resulting in a smooth triangulation of the lattice, featuring rounded struts' sections, variable radiuses, and blends at nodes. This method has two major limitations: the result contains a very large number of triangles, and the size of blends joining struts' surfaces cannot be controlled.
Direct slicing approaches generate slices directly from an implicit lattice representation such as CSG tree [12], layered depthnormal images (LDNI) [13], avoiding the need to create a watertight triangulation.
A direct slicing method for NURBS surfaces was proposed in [14]. The method is based on a raycasting technique. Rays are casted in the plane of the layer, intersection points with the surface are stored, along with their entry/exit status and their surface's normal. The slice geometry is then generated by connecting neighbor points, based on normal directions and points status. The method can be applied to weak BRep definitions, such as nonwatertight solids, or overlapping surfaces. The major limitation of this approach is the need for a CAD BRep input, for which CAD modelers are highly inefficient to generate.
A Raytracing direct slicing method was proposed to generate bitmap images of slices directly from the mathematical description of CSG primitives representing the lattice structure [12]. The limitation of this approach is the pixelation of bitmaps which requires significant resolution to represent the layers with the accuracy requirements.
Quador beams [15] are surfaces that generalize the straight (cone) beams to quadric surface of revolution (revolution of line, hyperbola, parabola, ellipse). Quador have both implicit and parameterized representation [16]. To create a direct slicer for lattice structures composed with Quador beams, authors in [17] proposed a raycasting algorithm to generate the planestrut intersection ellipses of the lattice slices. This method generates slices with the accuracy defined by the resolution of the slice image.
The algorithm presented in this article can be summarized as follows. The first step is the explicit definition of geometry parameters of plain cylinders, cones and cap spheres attached to the input skeleton format. Then, the tentative curves generated by the intersection between the geometry and the slicing plane are trimmed in order to only retain subsets lying on the boundary of the lattice 3D domain. The results represent the layer of the slice with a set of closed contours, each of which consisting in the sequence of parametric curves representing the boundary domain of the layer.
Our specific contribution in this article is a slicing method acting directly on skeleton models representing a lattice structure as a graph of struts and nodes [2].
The proposed slicer algorithm bypasses STL file generation. Unlike other direct slicing approaches relying on raycasting methods with an accuracy relative to the grid resolution, our method relies on a CAD kernel and generates the parametric curves describing the exact geometry of the lattice slices, based on intersection curves between parameterized representation of strut surfaces (cones, cylinders) and the slicing plane. The paper is organized as follows. Section 2 defines the geometric model of the lattice structure. Section 3 presents an overview of the proposed approach for the slicing procedure. Section 4 presents the 3D definition of independent cones, cylinders, and spheres attached to lattice's struts. Section 5 presents the direct slicing method that generates the set of tentative curves, and the first step that discards struts lying outside the slicing plane. Section 6 presents the trimming of interior subsets in candidate curves, producing the slice boundary on cones or cylinders. Section 7 presents the plane intersection of cap spheres that produces the slice boundary lying on spheres. For a quick overview, the graphical abstract in Appendix A.1 presents graphically the whole process.
2 Geometric model for lattice structures
Optimizing the material usage in lattice structures leads to configurations where the relative density is variable throughout the whole design space. The dimension of each elementary cell and the radius of each strut can vary throughout the design space to produce the optimized lattice structure. Indeed, the generation of this truss structure relies on a skeleton model, as described in [3]. This skeleton model entails a set of point coordinates corresponding to each vertex of the truss structure. Parameters thus include the coordinates of each node, the connectivity between each node (describing how they are connected), as well as a radius assigned to each node. To fill a cube with truss structures of variable density, the dimension of each elementary cell remains constant, with only the beam size varying. However, to fill a cylindrical geometry with variable density, it is necessary to slightly adjust the dimension and geometry of the unit cell to fit this specific geometry, as well as vary the beam size.
This optimized lattice structure generates a skeleton model, which is the input data of the slicer.
The skeleton model is decomposed into a set of nodes and a set of struts linking them. Each node has two or more adjacent struts. Struts' cone shapes, tangent to node spheres, represent the linearly changing size of struts between nodes. The addition of cap spheres at nodes not only smoothens and simplifies the geometry, but also avoids the presence of stress raisers (see Fig. 1).
The graph G = (V,E), represents the lattice topology where V is the set of vertices and E is the set of edges, each of which representing a strut E_{i,j} connecting vertices V_{i} and V_{j}. Each vertex V_{i} represents a sphere Ω_{Vi} centered on point P_{i} and featuring radius R_{i}. Each edge E_{i,j} represents a strut with Ω_{Ei,j} being either a cylinder if R_{j} = R_{i}, or a finitelength cone tangent to spheres Ω_{Vi}, Ω_{Vj} otherwise (see Fig. 2). The lattice volume Ω_{L} is the union of spheres Ω_{Vi} and cones Ω_{Ei,j} (see Fig. 2):
$${\text{\Omega}}_{L}=\left({\displaystyle \underset{i}{{\displaystyle \cup}}}{\text{\Omega}}_{Vi}\right)\cup \left({\displaystyle \underset{i,j}{{\displaystyle \cup}}}{\text{\Omega}}_{Ei,j}\right)$$
$$\forall {V}_{i}\in V\left(G\right);\forall {E}_{i,j}\in E\left(G\right).$$
This graphbased data structure is computationally efficient to describe lattice structures having hundreds of thousands of struts, and is adapted to develop direct slicing algorithm.
The direct slicing algorithm works with an exact, nontriangulated, representation of the solid geometry, and converts directly each 3D primitive into 2D section slices containing exact slice curves.
The terms adjacency, connected, neighborhood, incident refer to usual definitions given in the Graph Theory [18].
Fig. 1 (a) The material discontinuity located at the intersection of adjacent struts (b) Discontinuity avoided by the insertion of cap spheres on nodes. 
Fig. 2 The graph representation for a lattice structure, (a) lattice graph with vertices Vi and Vj and edges E_{i,j}, (b) sphere Ω_{Vi} and cones Ω_{Ei,j} primitives 
3 The proposed approach
The slicing direction is chosen as the Z‐direction, and each slice represents the geometry of the layer printed at a given Z coordinate. A slice of the solid Ω_{L} with the slicing plane Π is the planar point set resulting from the Boolean intersection Ω_{L} ∩ Π. Each slice must be represented by the set of oriented curves representing the boundary between interior and exterior domains of the slice, forming closed loops and oriented in the counterclockwise sense. The slicing method consists in evaluating the boundary of the intersection, i.e. C^{sli} = ∂ (Ω_{L} ∩ Π).
The slice boundary can be computed by the following algorithm, which is an instance of the familiar generateandtest paradigm in Computer Science:
Generate a sufficient set of tentative curves {C^{t}} ⊃ C^{sli}.
For each C^{t} do.
Discard segments of C^{t} which are not on ∂Ω_{L}.
$${C}^{sli}={C}^{sli}\cup \left({C}^{t}\subset \partial {\text{\Omega}}_{L}\right).$$
Sufficient sets of tentative curves can be generated by using the basic fact ∂ (A ∪ B) ⊂ (∂ A ∪ ∂ B). Slice boundary is hence a subset of primitives' slice boundary ∂Ω ∩ Π:
$$\left\{{C}^{t}\right\}={\displaystyle \underset{i}{{\displaystyle \cup}}}\left(\partial {\text{\Omega}}_{Vi}\cap \Pi \right)\cup {\displaystyle \underset{i,j}{{\displaystyle \cup}}}\left(\partial {\text{\Omega}}_{Ei,j}\cap \Pi \right).$$
The following method evaluates the slice using above property:
Let S_{Vi} = ∂ Ω_{Vi} be the boundary surface of Ω_{Vi}, S_{Ei,j} = Ω_{Ei,j} be the boundary surface of Ω_{Ei,j}, and Π the slicing plane.

Generate sets of tentative curves on cones by intersecting cone surfaces S_{Ei,j} with slicing plane Π (see Fig. 3a)
$$\left\{{C}_{Ei,j}^{t}\right\}={S}_{Ei,j}\cap \Pi \forall {E}_{i,j}\in E\left(G\right).$$

Discard segments from $\left\{{C}_{Ei,j}^{t}\right\}$ which are inside the neighbor cones Ω_{Ek,l} (see Fig. 3b):
$$\left\{{C}_{Ei,j}^{}\right\}=\left\{{C}_{Ei,j}^{t}\right\}\setminus {\text{\Omega}}_{Ek,l}$$
$$\forall {E}_{k,l}\in N\left({E}_{i,j}\right)$$
Where A\B is the set of points in A but not in B.

Generate sets of tentative curves on spheres by intersecting sphere surfaces S_{Vi} with plane Π(see Fig. 3a)
$$\left\{{C}_{Vi}^{t}\right\}={S}_{Vi}\cap \Pi \forall {V}_{i}\in V\left(G\right).$$

Discard segments from $\left\{{C}_{Vi}^{t}\right\}$ which are inside the cones Ω_{Ei,j} incident to sphere Ω_{Vi} (see Fig. 3b):
$$\left\{{C}_{Vi}\right\}=\left\{{C}_{Vi}^{t}\right\}\backslash {\text{\Omega}}_{Ei,j}\forall {E}_{i,j}\in E\left(G\right)$$
where A\B is the set of points in A but not inB.
Fig. 3 (a) nodes and strut slices, (b) lattice boundary slices. 
4 Sphere and cone primitives
The shape of strut E_{i,j} is the Boolean union of three solid primitives: one finitelength cone Ω_{Ei,j} (see Fig. 4a), and two spheres Ω_{Vi} and Ω_{Vj} of radiuses R_{i} and R_{j} centered on points P_{i} and P_{j} (see Fig. 4b). The cone's side surface S_{Ei,j} is tangent to spheres S_{Vi} and S_{Vj} along circles ${C}_{i,j}^{b}$ and ${C}_{i,j}^{c}$ (Fig. 4c).
The finitelength cone is defined by its base point, cap point, base radius, and cap radius (see Figs. 5 and 6).
The following equations present struts' geometry completely derived from lattice vertices attributes (P_{i}, R_{i}).
The semiangle α_{i,j} of the cone S_{Ei,j} is:
$${\alpha}_{i,j}=\text{asin}\left(\frac{{R}_{j}{R}_{i}}{{P}_{i}{P}_{j}}\right)$$
where P_{i}P_{j} = P_{j}–P_{i}.
Base and cap circles are normal to P_{i}P_{j}.
Base circle parameters:
Radius ${R}_{i,j}^{b}={R}_{i}\cdot \text{cos\hspace{0.17em}}{\alpha}_{i,j}$
Center ${P}_{i,j}^{b}={P}_{i}{R}_{i}\cdot \frac{{P}_{i}{P}_{j}}{\left\left{P}_{i}{P}_{j}\right\right}\text{sin\hspace{0.17em}}{\alpha}_{i,j}$.
Cap circle parameters:
Radius ${R}_{i,j}^{c}={R}_{j}\cdot \text{cos\hspace{0.17em}}{\alpha}_{i,j}$
Center ${P}_{i,j}^{c}={P}_{j}{R}_{j}\cdot \frac{{P}_{i}{P}_{j}}{\left\left{P}_{i}{P}_{j}\right\right}\text{sin\hspace{0.17em}}{\alpha}_{i,j}$.
Return value: cone ${S}_{{E}_{i,j}}$ and circles ${C}_{i,j}^{b}$;${C}_{i,j}^{c}$
Axis' direction: P_{i}P_{j} = P_{j} − P_{i}
Cone Semiangle: ${\alpha}_{i,j}=\text{asin}\left(\frac{{R}_{j}{R}_{i}}{{P}_{i}{P}_{j}}\right)$
Create cone surface:
$${S}_{{E}_{i,j}}=Cone\left({P}_{i,j}^{b},{P}_{i}{P}_{j},{R}_{i,j}^{b},{\alpha}_{i,j}\right)$$
Create cone base circle ${C}_{i,j}^{b}$:
$$center={P}_{i,j}^{b}={P}_{i}{R}_{i}\cdot \frac{{P}_{i}{P}_{j}}{\left\left{P}_{i}{P}_{j}\right\right}\text{sin}{\alpha}_{i,j}$$
$$radius={R}_{i,j}^{b}={R}_{i}\cdot \text{cos}{\alpha}_{i,j}$$
$${C}_{i,j}^{b}=Circle\left(center,radius,normal\right)$$
Create cone cap circle ${C}_{i,j}^{c}$:
$$center={P}_{i,j}^{c}={P}_{j}{R}_{j}\cdot \frac{{P}_{i}{P}_{j}}{\left\left{P}_{i}{P}_{j}\right\right}\text{sin}{\alpha}_{i,j}$$
$$radius={R}_{i,j}^{c}={R}_{j}\cdot \text{cos}{\alpha}_{i,j}$$
Fig. 4 geometry of a strut E_{i,j}. 
Fig. 5 Cone primitive definition. 
Fig. 6 Cone parameters. 
5 The proposed direct slicing method
The slicing works with four geometric steps:
ZBuffering: (See step 1 in Fig. 7) Zbuffers are lists of struts intersected by each slice section plane Π_{i} defined as Z_{i} = z_{0} + i ⋅ Δz ∀ i ∈ [0 ; N − 1].
Slicing procedure on cones/cylinders: (See step 2 in Fig. 7) The set of intersected struts contained in the slice ZBuffer is retrieved. The cone and cylinder surfaces are sliced. The result is a set of edges representing the exact geometry of struts' section.
Trimming of interior edges: (See step 3 in Fig. 7) for each slice curve, the slices of adjacent struts are merged by intersecting/splitting edges, and removing interior subsets.
Slicing procedure on cap spheres: (See step 4 in Fig. 7) cap sphere subdomains lying on the outside of adjacent struts are sliced, forming arcs of circles.
Fig. 7 The four slicing steps. 
5.1 Rejection test and Zbuffering (step 1)
The lattice domain is explored along Z axis to discard struts that are guaranteed not to intersect the slicing plane, thus minimizing the number of intersection tests (see Fig. 8). The height of the first layer is Z = Z_{0}, and next section planes are equally spaced by the ΔZ layer thickness. Hence, the height of the k^{th} section plane designated Π_{k} is Z_{k} = Z_{0} + k. ΔZ.
Each Zbuffer refers to the k^{th} slice, section plane Π_{k}, and the list of intersected struts. The Zbuffering is obtained using minmax coordinates of struts along Z axis.
Given a strut Ω_{Ei,j}, its minmax coordinates along Z axis are:
$${Z}_{min}\left({\text{\Omega}}_{Ei,j}\right)=\mathrm{min}\left({P}_{i}\cdot z{R}_{i};{P}_{j}\cdot z{R}_{j}\right)$$
$${Z}_{max}\left({\text{\Omega}}_{Ei,j}\right)=\mathrm{max}\left({P}_{i}\cdot z+{R}_{i};{P}_{j}\cdot z+{R}_{j}\right).$$
Strut Ω_{Ei,j} is cut by plane Π_{k} if $k\in \left[\text{sup}\left(\frac{{Z}_{min}\left({\text{\Omega}}_{Ei,j}\right){Z}_{0}}{\Delta Z}\right);\text{inf}\left(\frac{{Z}_{max}\left({\text{\Omega}}_{Eij}\right){Z}_{0}}{\Delta Z}\right)\right]$.
Fig. 8 Zbuffer: (left) Bounding box of a strut, (right) struts intersected by the plane are colored in red. 
6 Slicing of cones/cylinders (step 2)
For all struts cut by plane Π_{k}, contained in ZBuffer at index k, their primitives are intersected with plane Π_{k} to generate slice curves. The process is decomposed in two independent tasks: the slicing of strut surfaces S_{Ei,j}, and the slicing of spheres S_{Vi}.
6.1 Slicing of strut surfaces (cone or cylinder)
Surfaces intersections S_{Ei,j} ∩ Π_{k} generate a set of tentative curves $\left\{{C}_{Ei,j}^{t}\right\}$ containing the slice boundary. Tentative curves are either circle, ellipse, line, parabola, or hyperbola. To filter the curve' subset lying on the lattice boundary, the process splits curve ${C}_{Ei,j}^{t}$ at struts' end circles ${C}_{i,j}^{b}$ and ${C}_{i,j}^{c}$ (see Figs. 9 and 10), and discards segments lying inside neighbor struts N (E_{i,j}), resulting in curves $\left\{{C}_{Ei,j}^{}\right\}$:
The tentative curve ${C}_{Ei,j}^{}$ is split at points $\left\{{P}_{i,j}^{b}\right\}={\Pi}_{k}\cap {C}_{i,j}^{b}$ and $\left\{{P}_{i,j}^{c}\right\}={\Pi}_{k}\cap {C}_{i,j}^{c}$ (see Fig. 9), resulting in $\left\{{C}_{Ei,j,l}^{t}\right\}$.
Each curve $\in {C}_{Ei,j,l}^{t}$ lie entirely either in the surface S_{Ei,j}, or in the exterior domain of Ω_{Ei,j}.
By pruning middle point of tentative curves' segments $Midpoint\left({C}_{Ei,j,l}^{t}\right)$, exterior segments are discarded, and only subsets lying entirely on surface S_{Ei,j} remain.
Fig. 9 Slicing of strut surface S_{Ei,j}: ellipse trimmed with ${C}_{i,j}^{b}$ and ${C}_{i,j}^{c}$ strut's bounding circles. 
Fig. 10 Strut surface slicing algorithm. 
7 Trimming of interior subsets (step 3)
The step 3 of the slicing algorithm consists in discarding subsets of tentative curves $\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}$ lying in interior of intersecting struts Ω_{Ek,l} such as $\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}\cap \left\{{\text{\Omega}}_{\text{Ek},\text{l}}\right\}\ne \varnothing $ (see Figs. 5.4 and 11).
A necessary condition for a strut E_{k,l} to intersect one tentative curve $\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}$ is the fact that his volume Ω_{Ek,l} intersects Ω_{Ei,j}. Also, the boundary of the subdomain of $\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}$ lying inside the intersecting strut Ω_{Ek,l} is located on the boundary surface S_{Ek,l} and the slicing plane Π_{k}, then on the tentative curves of the intersecting strut $\left\{{\text{C}}_{\text{Ek},\text{l}}^{t}\right\}={\text{S}}_{\text{Ek},\text{l}}\cap {\Pi}_{\text{k}}$. Trimming $\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}$ parts interior to Ω_{Ek,l} is then done by splitting curves at their intersection point with $\left\{{\text{C}}_{\text{Ek},\text{l}}^{t}\right\}$, and discarding parts interior to Ω_{Ek,l}. The test $\text{Midpoint}\left({\text{C}}_{\text{Ei},\text{j},\text{n}}^{\text{t}}\right)\in {\text{\Omega}}_{\text{Ek},\text{l}}$ is done to identify elements to discard.
Input: plane Π_{k}, strut E_{i,j}
Return value: $\left\{{C}_{Ei,j,n}^{}\right\}$ = slice curves generated by strut E_{i,j}
{E_{k,l}} = Get the list of struts that intersect strut E_{i,j}, such as Ω_{Ek,l}∩ Ω_{Ei,j} ≠ ∅
$\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}$ = Get the tentative curves formed by the slice of strut's surface S_{Ei,j} ∩ Π_{k},
$\left\{{\text{C}}_{\text{Ek},\text{l}}^{t}\right\}$ = Get the tentative curves formed by the slice of strut's surface S_{Ek,l} ∩ Π_{k}.
$\left\{{C}_{Ei,j,n}^{t}\right\}$ = Split $\left\{{\text{C}}_{\text{Ei},\text{j}}^{t}\right\}$ curves by inserting vertices at their intersection points with $\left\{{\text{C}}_{\text{Ek},\text{l}}^{t}\right\}$.
$\left\{{C}_{Ei,j,n}^{}\right\}$ = Discard elements of $\left\{{C}_{Ei,j,n}^{t}\right\}$ if they lie inside the interior of Ω_{Ek,l}.
8 Slicing of caps spheres (step 4)
This process aims at the generation of arcs forming the slice curves lying on cap spheres S_{Vi}.
First, the set of tentative arcs $\left\{{C}_{Vi,j}^{t}\right\}$ is built by intersecting slice plane Π_{k} against each sphere S_{Vi} domain lying outside adjacent strut Ω_{Ei,j} (see Figs. 12a and 12b):
$$\left\{{C}_{Vi,j}^{t}\right\}=\left({S}_{Vi}{\text{\Omega}}_{Ei,j}\right)\cap {\Pi}_{\text{k}}\forall j\in N\left({V}_{i}\right).$$
The slice curves lying on sphere S_{Vi} are the common parts of tentative arcs in $\left\{{C}_{Vi,j}^{t}\right\}$ (see Figs. 12c and 13):
$$\left\{{C}_{Vi}^{n}\right\}={\cap}_{j}{C}_{Vi,j}^{t}\forall j\in N\left({V}_{i}\right).$$
Each tentative arc $\left\{{C}_{Vi,j}^{t}\right\}$ is constructed as following:
Circle C_{i} = S_{Vi} ∩ Π_{k} is found.

End points $\partial {C}_{Vi,j}^{t}$ of tentative arc ${C}_{Vi,j}^{t}$ are located on circle ${C}_{i,j}^{b}$ which is the intersection of S_{Vi} and S_{Ei,j} (see Figs. 12 and 13). As ${C}_{Vi,j}^{t}$ lies inside the slice plane Π_{k} (see Fig. 12):
$$\partial {C}_{Vi,j}^{t}=\left\{{P}_{i,j}^{b}\right\}=\left\{{C}_{i,j}^{b}\right\}\cap {\Pi}_{k}.$$
Tentative arc ${C}_{Vi,j}^{t}$ is the part of C_{i} bounded by $\left\{{P}_{i,j}^{b}\right\}$ and lying outside Ω_{Ei,j}.
Tentative arcs ${C}_{Vi,j}^{t}$ belong to different parametric intervals of the same circle C_{i}, defined as [L_{i,j} ; U_{i,j}] ⊂ [− π ; 3π] where L_{i,j} ≤ U_{i,j} + 2π (see Fig. 13).
Parametric intervals of slice curves are obtained by intersecting tentative arcs intervals all together:
$\left\{\left[{L}_{i}^{n};{U}_{i}^{n}\right]\right\}={\cap}_{j}\left(\left[{L}_{i,j};{U}_{i,j}\right]\right)$.
Fig. 11 Trimming interior edges. 
Fig. 12 slice curves lying on sphere S_{Vi} are the intersection of tentative arcs $\left\{{C}_{Vi}^{n}\right\}={\cap}_{j}{C}_{Vi,j}^{t}\forall j\in N\left({V}_{i}\right)$. 
Fig. 13 Slice on a sphere. 
9 Examples and discussion
Testcase #1: this stem lattice structure illustrated in Figure 14 has conical struts with radii varying in [0.4 ; 1.2] mm. This test aims at demonstrating that the slices generated by our slicer are faithful, and fast generated. The lattice structure contains 4700 struts. The 324 layers have been generated in 795 ms. The layers have been saved in a CLI formatted file, and has been readed successfully using netfabb software. The computation time of traditional CAD+STL involves generating the BRep model of the truss structure, exporting it in STL format, and subsequently generating slices from the STL file. The time with traditional CAD+STL slicing approach is 96 hours.
The algorithm efficiency has been tested on octet truss lattice structures having the cell pattern repeated a = 1, 2, 4, 8 times along each axis (see Fig. 15).
The layer thickness was set to 25 μm, and the cell size was 10 mm (maximum distance along X,Y,Z axis between nodes of a unitcell), strut diameter was 1 mm.
In Figure 16, the total time of skeleton lattice creation and direct slicing was compared with the traditional CAD+STL slicing approach. CAD files were built on CATIA V5 using the pattern copy feature in X, Y and Z directions. The BRep CAD model of the lattice was tessellated using a 0.01 mm sag error and exported in a STL file. Then, CuraEngine [19] processed STL files. The STL slicer generates rough polygons while direct skeleton slicing generates exact slicing curves.
The graph in Figure 17 shows that the trend curve of CAD+STL execution time grows as a^{4} due to the CAD model generation time, while the direct slicing approach grows as a^{3} which is much faster. As the number of intersected struts is proportional to a^{2} and the number of slices is proportional to a^{1}, the overall slicing complexity is proportional to a^{3}. The direct slicing time verify this cubic complexity behavior as the time scales cubically with a. In addition, the partcutting process is simplified, from four steps with the traditional CAD + STL approach to just two with the proposed approach. This method eliminates the need to deal with intersections between lattice beams and spheres, as well as the STL file generation steps, as demonstrated in Figure 18.
Fig. 14 Slices on the lattice structure of a stem. 
Fig. 15 Octet truss lattice structures for X,Y,Z pattern count a = 1, 2, 4, 8, each cell has 10mm side length, and 1mm of strut diameter. 
Fig. 16 Comparison of Catia V5 + STL slicing runtimes and between the proposed direct slicing method runtimes. 
Fig. 17 Time comparison between skeleton slicing and CAD+STL slicing. 
Fig. 18 Comparison of the CAD + STL approach with the proposed approach. 
10 Conclusion and perspectives
The direct slicing algorithm developed here outperforms the conventional method of producing and then slicing STL description of the part geometry, for sphereconecylinder based lattice structures. The method is well adapted to lattice structures having struts with variable diameters, and can be extended to process lattice structures having different strut size incident to the same node.
A possible direct extension of this method is the creation of blends directly on slice curves located near struts joints, to avoid stress concentration compromising the strength of the structure.
Another extension of this work would be the application of the proposed algorithm to Quador surfaces and Quador struts, which are currently not implemented in the OpenCascade CAD kernel [20].
Funding
The Article Processing Charges for this article are taken in charge by the French Association of Mechanics (AFM).
Conflicts of interest
The authors state that they don't have any conflicts of interest with respect to the research, authorship, or publication.
Data availability statement
All data generated or analyzed during this study are included in the present article.
Author contribution statement
Gilles Foucault: Methodology, Software development, Writing − original draft, Validation. PierreThomas Doutre: Writing − review & editing, test latticestructure “stem”, Validation. Frédéric Vignat: review & editing, Methodology.
Appendix A
Fig. A.1 Graphical abstract. 
References
 M. Suard et al., Mechanical equivalent diameter of single struts for the stiffness prediction of lattice structures produced by Electron Beam Melting, Addit. Manufactur. 8, 124–131 (2015) [CrossRef] [Google Scholar]
 A.H. Azman, F. Vignat, F. Villeneuve, CAD tools and file format performance evaluation in designing lattice structures for additive manufacturing, J Teknologi 80 (2018). doi: 10.11113/jt.v80.12058 [Google Scholar]
 A.H. Azman, F. Vignat, F. Villeneuve, D.S. Nguyen, Creation of lattice structures with skeleton model for additive manufacturing, Int. J. Interactive Des. Manufactur. 15, 381–396 (2021) [CrossRef] [Google Scholar]
 M.K. Thompson et al., Design for additive manufacturing: trends, opportunities, considerations, and constraints, CIRP Ann. 65, 737–760 (2016) [CrossRef] [Google Scholar]
 J. Gardan, Additive manufacturing technologies: state of the art and trends, Int. J. Product. Res. 54, 3118–3132 (2016) [CrossRef] [Google Scholar]
 F. Bianconi, Bridging the gap between CAD and CAE using STL files, Int. J. CAD/CAM 2, 55–67 (2002) [Google Scholar]
 Y. Chen, A meshbased geometric modeling method for general structures, in IDETCCIE2006, Volume 3: 26th Computers and Information in Engineering Conference (2006) p. 269–281 [Google Scholar]
 Slic3r − Open source 3D printing tool box. [En ligne]. Disponible sur: https://slic3r.org/ [Google Scholar]
 W.E. Lorensen, H.E. Cline, Marching cubes: a high resolution 3D surface construction algorithm, in Proceedings of the 14th Annual Conference on Computer Graphics and Interactive , in SIGGRAPH '87. New York, NY, USA: ACM (1987), p. 163–169 [CrossRef] [Google Scholar]
 L. Chougrani, J.P. Pernot, P. Véron, S. Abed, Lattice structure lightweight triangulation for additive manufacturing, Comput.Aid. Des. 90, 95–104 (2017) [CrossRef] [Google Scholar]
 G. Savio, R. Meneghello, G. Concheri, Optimization of lattice structures for additive manufacturing technologies, in Proceedings of the International Joint Conference on Mechanics, Design Engineering & Advanced Manufacturing (JCM 2016), in Lecture Notes in Mechanical Engineering. Catania, Italy: Springer Verlag (2016) [Google Scholar]
 M.C. Messner, A fast, efficient direct slicing method for slender member structures, Addit. Manufactur. 18, 213–220 (2017) [CrossRef] [Google Scholar]
 C. Yong, Regulating complex geometries using layered depth‐normal images for rapid prototyping and manufacturing, Rapid Prototyp. J. 19, 253–268 (2013) [CrossRef] [Google Scholar]
 B. Starly, A. Lau, W. Sun, W. Lau, T. Bradbury, Direct slicing of STEP based NURBS models for layered manufacturing, Comput. Aided Des. 37, 387–397 (2005) [CrossRef] [Google Scholar]
 A. Gupta, G. Allen, J. Rossignac, QUADOR: QUADricOfRevolution beams for lattices, Comput. Aided Des. 102, 160–170 (2018) [CrossRef] [MathSciNet] [Google Scholar]
 A. Gupta, G. Allen, J. Rossignac, Exact representations and geometric queries for lattice structures with quador beams, Comput. Aided Des. 115, 64–77 (2019) [CrossRef] [Google Scholar]
 S.S. Mustafa, I. Lazoglu, A new model and direct slicer for lattice structures, Struct. Multidisc. Optim. 63, 2211–2230 (2021) [CrossRef] [Google Scholar]
 J.A. Bondy, U.S.R. Murty, Graph theory with applications, Fifth printing, 1982. Elsevier Science Publishing Co., Inc. (1976) [CrossRef] [Google Scholar]
 Ultimaker Cura: Powerful, easytouse 3D printing software, ultimaker.com. https://ultimaker.com/software/ultimakercura [Google Scholar]
 Open CASCADE Technology  Collaborative development portal. Consulté le: 19 avril 2024. https://dev.opencascade.org/ [Google Scholar]
Cite this article as: G. Foucault, F. Vignat, P.T. Doutre, A direct slicing method for optimized lattice structures, Mechanics & Industry 25, 26 (2024)
All Figures
Fig. 1 (a) The material discontinuity located at the intersection of adjacent struts (b) Discontinuity avoided by the insertion of cap spheres on nodes. 

In the text 
Fig. 2 The graph representation for a lattice structure, (a) lattice graph with vertices Vi and Vj and edges E_{i,j}, (b) sphere Ω_{Vi} and cones Ω_{Ei,j} primitives 

In the text 
Fig. 3 (a) nodes and strut slices, (b) lattice boundary slices. 

In the text 
Fig. 4 geometry of a strut E_{i,j}. 

In the text 
Fig. 5 Cone primitive definition. 

In the text 
Fig. 6 Cone parameters. 

In the text 
Fig. 7 The four slicing steps. 

In the text 
Fig. 8 Zbuffer: (left) Bounding box of a strut, (right) struts intersected by the plane are colored in red. 

In the text 
Fig. 9 Slicing of strut surface S_{Ei,j}: ellipse trimmed with ${C}_{i,j}^{b}$ and ${C}_{i,j}^{c}$ strut's bounding circles. 

In the text 
Fig. 10 Strut surface slicing algorithm. 

In the text 
Fig. 11 Trimming interior edges. 

In the text 
Fig. 12 slice curves lying on sphere S_{Vi} are the intersection of tentative arcs $\left\{{C}_{Vi}^{n}\right\}={\cap}_{j}{C}_{Vi,j}^{t}\forall j\in N\left({V}_{i}\right)$. 

In the text 
Fig. 13 Slice on a sphere. 

In the text 
Fig. 14 Slices on the lattice structure of a stem. 

In the text 
Fig. 15 Octet truss lattice structures for X,Y,Z pattern count a = 1, 2, 4, 8, each cell has 10mm side length, and 1mm of strut diameter. 

In the text 
Fig. 16 Comparison of Catia V5 + STL slicing runtimes and between the proposed direct slicing method runtimes. 

In the text 
Fig. 17 Time comparison between skeleton slicing and CAD+STL slicing. 

In the text 
Fig. 18 Comparison of the CAD + STL approach with the proposed approach. 

In the text 
Fig. A.1 Graphical abstract. 

In the text 
Current usage metrics show cumulative count of Article Views (fulltext article views including HTML views, PDF and ePub downloads, according to the available data) and Abstracts Views on Vision4Press platform.
Data correspond to usage on the plateform after 2015. The current usage metrics is available 4896 hours after online publication and is updated daily on week days.
Initial download of the metrics may take a while.