Zygote structure enables pluripotent shape-transforming deployable structure Open Access

Abstract

We propose an algorithmic framework of a pluripotent structure evolving from a simple compact structure into diverse complex 3D structures for designing the shape-transformable, reconfigurable, and deployable structures and robots. Our algorithmic approach suggests a way of transforming a compact structure consisting of uniform building blocks into a large, desired 3D shape. Analogous to a fertilized egg cell that can grow into a preprogrammed shape according to coded information, compactly stacked panels named the zygote structure can evolve into arbitrary 3D structures by programming their connection path. Our stacking algorithm obtains this coded sequence by inversely stacking the voxelized surface of the desired structure into a tree. Applying the connection path obtained by the stacking algorithm, the compactly stacked panels named the zygote structure can be deployed into diverse large 3D structures. We conceptually demonstrated our pluripotent evolving structure by energy-releasing commercial spring hinges and thermally actuated shape memory alloy hinges, respectively. We also show that the proposed concept enables the fabrication of large structures in a significantly smaller workspace.

Introduction

Nature-inspired shape-programmable structures have generated substantial interest in mathematics, applied physics, computer science and graphics, materials science, robotics, and biological engineering (1–7). Diverse structures in nature are sometimes constructed by a combination of basic units under simple, rational algorithms (8, 9). For example, complex patterns on leaves are composed of a single geometry and its repetition called a fractal, e.g. veins on a leaf branch off in the form of a self-similar geometry (10). The living organism also grows and evolves based on the combination of four units (i.e. DNA consisting of combination of four nucleotides). This coded information determines how a small zygote (a fertilized egg) proliferates and grows into the preprogrammed shape (Fig. 1A) (11–13). In addition, proteins with complex 3D structures are synthesized with a combination of only 20 amino acids. The preprogrammed information called codons in mRNA determines the sequence of the amino acids (Fig. 1B) (14–16). In other words, nature may consist of simple geometry and an algorithm determining their combination.

Analogous to these growing and evolving systems of nature, researchers have shown that the rational design of simple unit structures can realize shape-programmable structures (17, 18). One of popular strategies is origami or kirigami (art of paper folding and cutting) structures. For example, Cho and colleagues suggest a fractal cut pattern that can program the shape of a kirigami-inspired deployable structure with only two cut motifs and their hierarchical arrangement (19). Recent studies have focus on the computational design of such origami or kirigami structures (17, 20–24). For example, Choi and colleagues reported a computational inverse design method of kirigami tessellations by using an objective function that minimizes the deviations between kirigami tessellations and the target shapes under defined boundary constraints. With simple cut patterns on a planar sheet, they obtained various deployed 2D and 3D kirigami shapes (22). They further developed their inverse design algorithm with an additive approach that enables the creation of a large variety of rigid-deployable, compact reconfigurable kirigami patterns (24). Another strategy is developing rational algorithms that construct desired structure with building unit blocks, rather than starting from a planar sheet. However, most previous computational approaches (i) were based on the disassembly and re-assembly of unit blocks, (ii) allowed the variation of unit blocks (i.e. building blocks have different sizes or shapes), or (iii) had limited deployability (i.e. the ability to expand its scale) (25–29). For example, Luo and colleagues developed a computational framework named legolization, in which arbitrary 3D structures are constructed by assembling basic building blocks; however, their algorithm requires disassembly and re-assembly for shape reconfiguration that hardly incorporate with recent self-folding systems for automation (27). Zhou and colleagues proposed a computational design approach that can enable the reconfiguration of a structure consisting of singly connected boxes into another shape through a sequential folding process (i.e. without a disassembly process); however, they allowed variation of the unit blocks rather than uniform building blocks preferred in diverse and efficient shape programming (28). Yu and colleagues suggested an algorithm that can be used to construct arbitrary 3D shapes with a single-chain structure consisting of uniform building blocks. Their single-chain structure can transform into diverse 3D structures by means of layer-by-layer coiling and stacking under computational guidance (29). Nevertheless, their algorithm has limited deployability because their coiling algorithm fills extra blocks into the inside of the final structure.

In this study, we first propose an origami (the art of paper folding)-inspired algorithmic approach for both shape-programmable structures (i.e. a structure that can change its shape into the desired form) and deployable structures (i.e. a structure that can change its size from a compactly small scale to a significantly large scale) consisting of uniform building blocks. In contrast to origami-based modular robots, which have mostly focused on shape transformation from a 2D state to a 3D structure or from a 3D shape to another 3D shape of a similar size (30–32), we aim to develop a super-compact structure consisting of uniform building blocks that can transform into diverse large 3D shapes, analogous to a pluripotent shape-transformable system in nature. Similar to the natural system, our shape-programming framework of pluripotent evolving structure, named a zygote structure, consists of fully connected thin, uniform building blocks. Controlling its connection path with a computationally designed coded sequence, it can be deployed into the preprogrammed structure.

Results and discussion

Basic concept of zygote structure

Fig. 1C shows the basic concept of our pluripotent evolving structure called zygote structure. All the building blocks are uniform square panels in our system. Starting from a given compactly stacked panels, we connect them according to the preprogrammed connection path (i.e. the computationally designed coded sequence) that can expand it into a desired 3D origami structure. A panel is physically connected with the upper or lower panel through one of its four sides by a rotational hinge. We constrained the rotation angles of the hinge to 90°, 180°, or 270° (Fig. 1D). In our simulation for the shape transformation, the hinges are designed to be stretchable to avoid the folding errors caused by thick panels (see Fig. S1). After connection, the stacked panels become a fully connected single-chain structure (which will be called a “stripified panels” hereinafter) that can be unfolded and reconfigured into a 3D origami structure. The compactly stacked structure can be transformed into diverse 3D structures according to the connection paths, as if the genetic codes represent certain physical features of creatures (11–13). In this framework, the number of possible connection paths increases exponentially with the number of panels N (proportional to 4^N × 3^N) since each panel has to be connected to an upper or a lower panel through one of four sides and the hinge can have one of three angles (90°, 180°, or 270°). Then, the key question is how we can find the coded sequence for a specific shape efficiently in this large search space. The computer science community has developed answers to this problem (28, 29). Rather than searching for the stacked state in this large space, previous studies have focused on finding connection paths of panels tessellating the surface of 3D structures before compacting them. Similar to these previous approaches, our stacking algorithm finds the path that can compactly stack 3D structures to solve this inverse problem.

Fig. 1E shows our stacking algorithm that transforms a 3D structure into stacked panels in which all panels are connected in a single-strip structure. To achieve this, we first approximate a curved 3D surface with square panels via voxelization (33). Then, we represent the voxelized surface as a dual-graph G = <V, E>, where each node in V corresponds to a square panel and each edge in E corresponds to a rotating hinge connecting the two neighboring panels. This inverse problem can be solved by finding the Hamiltonian path P, i.e. a path that visits all of the vertices on the given G, as illustrated in Fig. S2A. In general, the Hamiltonian path problem (HPP) is nondeterministic polynomial-time complete (NP-complete); however, Hamiltonian cycles must exist in the dual graph of the voxelized mesh as a four-regular graph (34). To solve this HPP, we used the traveling salesman problem (TSP) solver, which finds a Hamiltonian cycle, i.e. a path with identical start and end, with minimum cost (35). Once a Hamiltonian cycle is found, we break the cycle at an arbitrary position. This inverse programming can be operated in almost linear time by the number of panels (Fig. S2B shows the operation time for diverse 3D surfaces). Cut and folded along P, the tessellated 3D surface can be transformed into stripified panels and stacked into a columnar pile. The stripified panels can be more compactly stacked with multiple piles, as shown in Fig. 1F. The yellow boxes in Fig. 1F show the conceptual configuration of the compaction process (details for this compaction process are illustrated in Fig. S3). Finally, we inversely use P as the connection path for shape programming, i.e. P for stacking can inversely guide the compactly stacked panels to deploy into the target 3D structure. For example, Fig. 1G shows the experimental result that compactly stacked square sheets connected by the coded sequence can deploy into a 3D turtle structure that has a 144 times larger bounding box size. More importantly, we can deploy stacked panels into different 3D structures just by re-arranging their connection path by finding alternative or different Hamiltonian paths for diverse 3D surfaces (Movie S1) as long as we can tessellate surface of a structure with the same number of panels.

In this aspect, we refer to given initial stacked panels as zygote structures to represent that this initial simple structure can deploy into diverse 3D structures under the guidance of the coded sequence, analogous to the zygote cell in an organism that is divided and grows into the preprogrammed shape. This computational design strategy can potentially contribute to the development of versatile, deployable, and shape-programmable structures, especially when combined with recent 4D-printing techniques or origami robots.

Implementation of tree-stacking algorithm into zygote structure

In practical realization, stripified panels can result in significant inaccuracy for transforming the compactly stacked structure into the 3D surface (or vice versa) because even small noises in the motion control of the folding hinges can be cumulated along the connection-path and cause large gaps or overlaps in the final structure (see Fig. S1C) (36). This problem can be reduced by representing the zygote structure as a spanning tree T in the graph G rather than a single Hamiltonian path P. While all vertices in P are <2 degree nodes (i.e. every panel can be physically connected with only two adjacent panels except the first and the last panel), the spanning tree T allows high-degree nodes (HDNs) with greater than three connections. Fig. 2A shows the conceptual configuration of the zygote structure in which panels are connected with a tree-path T rather than a single Hamiltonian path P; panels in a pile are connected with a Hamiltonian path, and each pile is connected with hinges called bridges. The panels having bridges correspond to the HDNs in T.

Fig. 2B details this tree stacking using an example of the plane sheet approximated with 12 × 12 quads (note that our stacking algorithm is valid for not only closed 3D structures but also unclosed structures such as a plane sheet). We first divide G with K subgraphs G_s. A Hamiltonian path P in G_s can potentially stack the corresponding panels into a single pile, i.e. the number of partitions determines the number of piles in the zygote structure. Multiple P in G_s increase the pluripotency of the zygote structure. One way to achieve this is to increase the number of edges, |E(G_s)|, within G_s since the diversity of finding P also increases due to higher inner connectivity. We also aim that all the piles have the same heights, i.e. each subgraph has the same number of vertices. This increases the deployability (i.e. volume expandability) of the pluripotent evolving structure. This partitioning problem can be considered as a balanced graph partitioning problem (37), which divides a graph into K components having an equal or similar size while minimizing the total weight of the edges connecting different components. In our system, all the weights of edges are set to 1. In this case, the generalized Fiduccia–Mattheyses algorithm can easily minimize the number of edges in the cut (38). However, the Fiduccia–Mattheyses algorithm starts from a random partition and optimizes it for the minimal cut length, so it does not guarantee an exactly equal number of vertices in K components and may result in unbalanced stacked panels (Fig. 2C) (39). To address this limitation, we repeat the Fiduccia–Mattheyses algorithm until it finds a balanced partition in which all components have the same number of nodes (Fig. 2D). Although this approach is a quite simple and brute-force alternative, this method was sufficient for partitioning models with few hundreds to thousands of meshes into <10 components.

After partitioning, we consider the placement of piles to maximize the connectivity between G_s. We set a hypergraph G_hyper as a 2D grid. Each node v_hyper in G_hyper corresponds to a subgraph $Gsi$ and occupies a single grid cell of the 2D grid, as shown in Fig. 2E. When the number of edges in G between two subgraphs $E(Gsi,Gsj)>0$⁠, an edge $ehyperi,j$ connects v_hyper,i and v_hyper,j with the weight of the edge $W(hyperi,j)=E(Gsi,Gsj)$⁠. Then, we can find the optimal hypergraph $Ghyper′$ as

This optimization problem can be solved by a dynamic-programming solver designed for subset sum problem (40).

Then, each K component finds an arbitrary Hamiltonian path Pⁱ (Fig. 2F). To construct a valid tree path, a Hamiltonian path Pⁱ should be adjusted to be connectable with its adjacent Hamiltonian path P^j on both the 3D structure and zygote structure, i.e. at least two adjacent nodes in each neighboring Hamiltonian path on the 3D structure should also be adjacent in the stacked state. To enforce this requirement, we optimize Pⁱ locally in each pile $Gsi$ to maximize connections between piles: (i) we select an arbitrary reference node v_hyper,r in $Ghyper′$⁠. Depending on their topological distance from v_hyper,r in G_hyper, any child node v_hyper,i is linked to its parent node v_hyper,j. (ii) Let $vxi$ be the xth node in Pⁱ; we place the stacked pile of Pⁱ, which corresponds to v_hyper,i, next to P^j with $v1i$ and $v1j$ being the bottom. Then, we recursively update the Pⁱ based on P^j until there are some $vxi$ in Pⁱ that potentially be connected to node $vxj$ in P^j (see Fig. S4). This matching function is defined as

which checks every pair of nodes $vxi$ and $vxj$ in Pⁱ and P^j that are on the same height x in the stacked configuration. (iii) We update Pⁱ using

where f_{geo match}(x) is the geometric matching function (Fig. 2G shows that P^B is updated to topologically match P^A. All Pⁱ are recursively updated in this way.). If there is already a hinge connecting $vxj$ and $vx+1j$ where the potential hinge between $vxi$ and $vxj$ should be in the stacked configuration, they cannot be linked since connecting them will result in nonmanifold geometries, as shown in Fig. S5. If f_match(x) violates this constraint, f_{geo match}(x) = 0; otherwise, f_{geo match}(x) = 1. (iv) To ensure this geometric matching constraint, we locally cut the Pⁱ and change the orientation of $vxi$⁠. For this process, we record all the xs that satisfy f_match(x) = 1 and put in a sorted vector $x→$ and ensure x_i < x_i+1 If $|x→|=1$⁠, which means that there is only one matching component, we can simply rotate the entire pile along with $vxi$⁠. However, if $|x→|>1$⁠, $vxi$ has to be detached from $vx−1i$ or $vx+1i$⁠, i.e. we break Pⁱ. We denote such a broken edge as $ebreaki$⁠. Then, $vxi$ and $vxj$ can be connected by an edge $ematchi$ connecting the neighboring piles (Fig. 2H). We call such $ematchi$ as a “bridge.” In our pluripotent evolving structure, these HDNs having three neighbors, including the bridge, correspond to the high-degree panels (i.e. panels corresponding to the HDNs) having three hinges (i.e. a hinge corresponding to the bridge connects panels in two adjacent piles, while the others connect the upper or lower panels). Finally, we obtain a zygote structure in which all panels are connected in the tree path as

where $Ematchi$ and $Ebreaki$ are the sets of all matching and broken edges in pile Pⁱ. This tree-stacking algorithm effectively reduces the large gaps or overlaps in the final structure by preventing the accumulation of folding errors (see Fig. S6) (36).

The tree-path T_s generated by the tree-stacking process can inversely guide the zygote structures having the same configuration of panels into an arbitrary target 3D structure. For example, Fig. 2I shows that a voxelized 3D fish model approximated with 144 square meshes is stacked into a zygote structure with 4 piles, which is the same as the zygote structure corresponding to the plane model approximated with 12 × 12 meshes (Fig. 2J and Movie S2). This implies that we can develop diverse structures from a single zygote structure by controlling only the connection path and folding angles of hinges guided by the coded sequences, i.e. the T_s can be used as a coded sequence for our pluripotent evolving structure.

It should be noted that at this stage, our tree-stacking algorithm does not include collision-free motion planning of the panels during transformation since our main objective is to find the connection paths that can guide the zygote structure into diverse 3D shapes. However, motion planning algorithm can be incorporated into our tree-stacking algorithm based on the previous works (36, 41). In addition, our tree-stacking algorithm aims for a different objective than recent polyhedron unfolding algorithms. In contrast to a polyhedron unfolding algorithm that flattens a 3D-meshed structure onto a 2D plane without self-overlapping, the panels may overlap if we flatten the zygote structure onto a 2D plane along the tree path (42, 43). If it is desired to create the flattened configuration and net a planar structure, we can require a 2D grid such that each node occupies a single grid cell, and all nodes are connected along T_s. For instance, in case of the T_s corresponding to the 3D fish approximated with 144 panels, there are grid cells that are occupied by more than two nodes, as shown in Fig. 2K (i.e. more than two panels can overlap in the flattened configuration). Even a single Hamiltonian path P can generate its self-overlapped planar figure, as shown in Fig. 2L. In this study, we do not consider self-collision or overlapped panels in flattened planar figures; therefore, all the possible connection paths obtained in the above process can be regarded as possible solutions. However, a global optimization problem with more restrictions could be established, such as minimizing the folding angles of hinges and the number of overlapping panels in flattened planar figure or avoiding self-collision during transformation.

Demonstration of algorithmic zygote structure

Fig. 3 shows examples of our zygote structure. According to the coded sequence generated by the tree-stacking algorithm, a zygote structure having 4,000 panels with 4 piles can evolve (i.e. deploy) into a chicken, a vehicle, and a fish model (Fig. 3A and Movie S3. Fig. S7 shows another case using 498 panels). Besides pluripotency, scale expandability is another advantage of the pluripotent evolving structure. It is obvious that the size of the evolved structure is related to the thickness of each panel. To quantitatively compare the volume compaction/expansion ratio, we used package volume, which is widely used in the shipping industry (44). Package volume measures the cuboid box size to compactly pack an object. In other words, the package volume expansion ratio (referred to as “VER” hereinafter), defined as $We×Le×HeWz×Lz×Hz$⁠, measures the ratio of bounding box volume (Length × Width × Height) between the zygote and evolved 3D structures (see Fig. S8). When the length of square panel L is 100 times the thickness t (i.e. L = 100 × t), the VER is 791, 431, and 1,077 for each chicken, vehicle, and fish model, respectively.

The number of panels (i.e. resolution) also affects VER. In general, the feasibility of tree stacking for high-resolution models (i.e. 3D models consisting of many panels) is determined by the number of partitions rather than the number of panels. More partitions are much more expensive to compute, as each pile must have at least one HDN, or the entire algorithm must restart. In addition, the equal size partitioning process is also expensive for more partitions since we must repeat the Fiduccia–Mattheyses algorithm. When we increased the number of piles to >6 for the 4,000 panels case, the algorithm fails to find the solution. Meanwhile, our implementation using the state-of-the-art TSP solver Concorde (35) could find P_s in each partition efficiently so that our pluripotent evolving structure can have high-resolution 3D models if we restrict the number of partitions.

For experimental demonstration, we generate a pluripotent evolving structure with 92 panels (Fig. 3B and Movie S4). A zygote structure with 2 piles can evolve into a vehicle having 13.7 VER or a fish having 15.6 VER when the length of square panel L is 20 times the thickness t (i.e. L = 20 × t). We prepared 92 plastic panels (20 cm × 20 cm × 1 cm size), triangular magnets for 90° and 270° rotating hinges, and cuboid magnets for 180° rotating hinges (Fig. S9 for detailed information). We attached the magnets on the side faces of the plastic panels according to the coded sequence of the 3D vehicle model. Then, we could easily transform it into the 3D vehicle guided by the coded sequence generated by the tree-stacking algorithm. Although only four panels meet the ground (wheels of the vehicle) and there are no internal supports, the final vehicle structure stably maintains its shape without collapse. The 3D vehicle can be folded back to the initial zygote state, and we can transform it again into the 3D fish model just by rearranging the magnets (i.e. simply detaching the magnets and reattaching them) according to its coded sequence (Fig. 3C and Movie S5). Fig. S9 shows a further demonstration with magnetic toy blocks or paper boxes.

Practical implications of zygote structure

We conceptually show that our zygote structure can be used as the fabrication platform for overcoming the limited working space. Fabrication of a large structure may require a large area larger than the final product, e.g. making a large structure difficult and sometimes impossible without assembly due to limited workspace area or volume. Deployable structures that can overcome these limitations are suggested in diverse research fields involving architecture and robotics; however, most of them consist of bars and construct open scaffold structures (45–47). In contrast to previous deployable structures, our pluripotent evolving structure can represent the external shape of the desired structures with thin panels. Fig. 4A–D illustrates that a 3D printed zygote structure having 92 panels with 2 piles can evolve into objects that are significantly larger than the printable size of the 3D printer. Our 3D printed panel has a size of 9 cm × 9 cm × 0.48 cm and has holes in its rounded side so that it can embed a cylindrical magnet with a diameter of 2 mm and length of 3 cm, as shown in Fig. 4B. These cylindrical magnets are used as universal hinges for all 90°, 180°, or 270° rotations, which enables shape reconfiguration without rearranging the hinges (i.e. without detaching and reattaching the hinges in the zygote state). In addition, our panel design enables inserting magnets even inside of the printed zygote structure (Fig. S10). Since all holes aligned along the four sides of each panel are exposed in the stacked configuration, we can insert magnets as the compactly printed configuration. According to the algorithmic result, we printed a zygote structure with 92 panels and 2 piles (Fig. 4A). For printing, we introduced small gaps between panels (0.2 mm) to prevent their adhesion. The final printed zygote structure has a size of 23 cm × 18.2 cm × 9 cm. Then, we inserted the cylindrical magnets in all of the holes of the panels (total 368 magnets). As shown in Fig. 4C, it could evolve (i.e. deploy) into an 81 cm × 72 cm × 18 cm airplane model with 31.3 VER by folding panels along its corresponding coded sequence. It could be folded back into the zygote state without an additional detaching process and could evolve again into a 63 cm × 27 cm × 27 cm size fish model (Fig. 4D). Both 3D structures have larger dimensions than the printable size (23 cm × 19 cm × 20 cm, marked in red in Fig. 4C and D). We acknowledge that the pluripotent evolving structure with higher resolution may practically result in unstable or floppy structures because it deploys into hollow 3D structures; however, this issue can practically be mitigated by adding additional hinges connecting the cut edges only at the target state or adding internal support. For robust final structures, it may potentially be integrated with internal folding struts inside the unit panels.

Our demonstration with a 3D printer further implies that our zygote structures can be incorporated with recent 4D-printing techniques (48–50) or origami robots (51–53). The zygote structure can easily incorporate these self-transformation systems because thin panels as building blocks have advantages in terms of light weight and integration with novel stimuli-responsive materials than volumetric building blocks (17, 52–56). To integrate the origami-robot techniques in our zygote structure, we introduce energy-releasing spring hinges and thermally actuated shape memory alloy (SMA) hinges in our pluripotent evolving structure. We are the first to demonstrate a shape-reconfigurable structure that can transform into multiple targets starting from a compact structure consisting of a thin, uniform panel. Figure 4E shows a simple zygote structure having 14 panels with 2 piles that can be deployed into an L- or an I-shaped 3D structure (Fig. S11 shows the flattened planar figures of both 3D structures with mountain-valley fold lines). We experimentally demonstrate the deployable zygote structure by assembling 3D printed 14 panels with commercial spring hinges; their rotation angles were controlled to be 90°, 180°, or 270° by welding steel bars on the spring hinges (Fig. 4F). The spring hinges can be inserted into one of four sides of the 3D printed panels (Fig. S12). First, we connected stacked panels with the spring hinges according to the coded sequence for the I-shape structure. Simply thrown into the air, it rapidly deploys into the final 3D structure, and the unfolded structure maintains its shape without additional supports. Then, we could transform it to the zygote structure easily by folding back guided by the hinges and detaching them and reconfiguring it into the L-shape structure in the same way (Fig. 4G and Movie S6). This demonstration using spring hinges enables fast and robust shape transformation, while recent stimuli-responsive self-folding systems experience delays caused by phase transformation or alignment of materials (17).

We further demonstrate that our pluripotent evolving structure can be combined with recent self-folding systems based on novel stimuli-responsive materials. Most of these systems are composed of functionalized or layered thin sheet-like structures (54–56). In other words, whether incorporating thin sheet-like hinges is possible is the key criterion to test the potential feasibility of introducing stimuli-responsive hinges. To demonstrate this, we simply introduce SMA sheets into our pluripotent evolving structure. We prepared 5 mm × 10 mm thin SMA sheets. They are folded to 90° and fixed, annealed at 450°C for an hour, and quenched in water. This process preprograms the shape of SMA sheets. Overlapping the programmed SMA by folding it in half with either 90° or 270°, we could prepare SMA hinges that can rotate and stop either at 90° or at 270°. Hinges for 180° rotation are prepared in the same manner (Fig. 4H. Detailed process is described in Fig. S13). Then, we prepared two zygote structures consisting of 14 pieces of paper and attached SMA hinges to each zygote structure guided by the coded sequence for each I- or L-shaped structure. Fig. 4I and Movie S7 show that the pluripotent evolving structure can deploy into the two 3D structures when we apply heat by a commercial heat gun. Stimuli-responsive materials have enabled diverse shape-transformable structures, but its integration with a computationally guided design system as in our study has been rarely reported.

In this study, we simply demonstrate a pluripotent evolving structure consisting of 14 panels with spring hinges or SMA hinges. Although physically realizing a zygote structure consisting of many panels with such stimulus-responsive hinges is currently challenging, further development of mechanical and electrical dynamic systems for hinges and panels, such as recent hydraulic- or motor-based moving hinges and MEMS panels (57–59), may enhance the structural stability during shape transformation. In addition, we believe that recent origami robots that embed circuit boards, sensors, or batteries can be applied to realize a functionalized shape-programmable origami robot (51–53).

Summary

We proposed the concept of the pluripotent evolving structure for designing a shape-transformable, reconfigurable, and deployable structure. Computational inverse design using our tree-stacking algorithm enables finding the connection paths that inversely guide compactly stacked uniform panels called the zygote structure into an arbitrary 3D structure. We demonstrated that our framework provides a shape-programmable structure with both high pluripotency and deployability. For example, we showed that this inverse design approach could transform a compact zygote structure having 4,000 panels into a chicken, a vehicle, and a fish model having 791-, 431-, and 1,077-times package volume sizes than their initial state. Thin building blocks in our zygote structure not only lead to extremely high deployability (i.e. volume expandability) but also potentially bring better feasibility for self-transformation combined with diverse self-folding mechanisms based on thin-film materials. We experimentally demonstrated the self-transformation of our pluripotent evolving structure with commercial spring hinges and SMA sheets. This further implies that our self-transformation system can be further incorporated with recent 4D-printing systems. In addition, it has versatile application rather than previous shape-programmable structures since conventional functionalized thin materials or fabrication processes for thin-film materials can be easily incorporated into the thin, uniform unit panels of our pluripotent evolving structure. One potential application is the design of wearable devices and robots, in which our pluripotent evolving structure provides tight conformability to the underlying shapes or human body. Recent autonomous origami robots embedding circuit boards or microcontroller can be applied to achieve it (51–53). In these aspects, our concept for pluripotent evolving structures not only contributes to the development of rational algorithms for shape-programmable structures in computer science and graphics, materials engineering, and architectures but also provides new insights into the development of portable, deployable, or 3D-shaped devices and robots in engineering fields involving materials engineering, electronic engineering, aerospace engineering, and robotics.

Materials and methods

We implemented the proposed stacking algorithm in C++. All data, including the running time illustrated in the supplementary materials, are collected on a MacBook Pro with a 2.5 GHz Intel Core i7 CPU with 16 GB memory running macOS 10.12. For the 3D-printed panels, we used commercial polylactic acid filaments. For the experimental demonstration with the SMA sheets, we used 0.125 mm thick nitinol foil (purchased from AVENTION Co., Ltd.)

Supplementary material

Supplementary material is available at PNAS Nexus online.

Funding

This work was supported by the National Research Foundation of Korea (NRF; grant numbers 2019R1A2C2003430, 2018M3A7B4089670, and 2016R1A5A1938472), the Creative-Pioneering Researchers Program through Seoul National University, and LG Display under the LGD–Seoul National University Incubation Program.

Author contributions

I.-S.C. conceived the concept. Y.H, Z.X, and J.-M.L. developed the stacking algorithms. Y.-K.L. and Y.H. generated the 3D models used in this paper and manipulated and implemented the algorithm. Y.-K.L., Y.P., and W.K. carried out experimental demonstrations. J.-M.L. and I.-S.C. supervised the project. Y.-K.L., Y.H., Z.X., K.-J.C., J.-M.L., and I.-S.C. wrote the paper.

Data availability

All data needed to evaluate the conclusions in the paper are presented in the paper and/or the supplementary materials. This manuscript was posted on a preprint: https://doi.org/10.48550/arXiv.2208.04204

References

Author notes