2.1. Modeling by example

Shape collections have been widely used to allow data-driven geometric modeling [Reference Xia, Araujo, Grossman and Wigdor13]. Modeling by example [Reference Funkhouser, Kazhdan, Shilane, Min, Kiefer, Tal, Rusinkiewicz and Dobkin14, Reference Chen, Zheng and Zhou15, Reference Schulz, Xu, Zhu, Zheng, Grinspun and Matusik16] enables the users to customize their own models by manipulating existing templates from a large database built by domain experts. More recent work uses recombination of model parts to expand the databases [Reference Kalogerakis, Chaudhuri, Koller and Koltun17]. Data-driven suggestions can be used to provide recommendations for designs [Reference Chaudhuri and Koltun18].

Perhaps the closest work to this project in terms of the desired goals comes from Schulz et al. [Reference Schulz, Shamir, Levin, Sitthi-amorn and Matusik19], in which models—including furniture—could be physically realized via modeling and fabrication by example. From an expert-created database of fabricable templates of finished designs, users could manipulate parameterized models with automatically positioning, alignment, and composition. This “model by example” process thus allows casual end-users to explore a predefined design space bounded by example designs created by domain experts. However, this “model by example” approach requires extensive efforts from domain experts to build a representative library of the targeted models. In our work, we propose a computational design pipeline for flat-pack furniture. Users are allowed to freely design their desired models with their manufacturability guaranteed.

Our system needs initial seed designs instantiated by experts, but they need not be any more than simple polygons (e.g., triangles and rectangles). From there, other desired planar and nonplanar geometries can be easily composed by casual users from the seed polygons using our hierarchical composition strategy (see Section 4.2). Expert users can further seed more complex assemblies—all the way up to complete furniture designs—to further simplify the design load on the casual user. The main difference from Schulz’s work comes from remixing components within that library, which can be done without any expert knowledge in our system; those new designs further extend the library, allowing for ever-growing complexity of designs without expert design.

2.2. Fabrication-aware design

Manufacturability of resulting models has long been a concern in the computer graphics community and attracted increasing interest recently [Reference Lau, Ohgawara, Mitani and Igarashi20]. Fabrication-aware design is proposed to guarantee generating fabricable models with fabrication specifications. It is based on digital parameterization of the building models and then implemented by considering the fabrication specifications through built-in algorithms. These systems with fabrication-aware design aimed at empowering novice users without desired skills to develop real-world designs.

Recently, an interactive system SketchChair [Reference Saul, Lau, Mitani and Igarashi21] was proposed to assist in designing chair models that can easily be fabricated and assembled. This system automatically generates a set of planar pieces that can be intersected along slots to form a 3D realization of a designed chair model. Inspired by the same idea, Chen et al. [Reference Chen, Sitthi-amorn, Lan and Matusik22] and Hildebrand et al. [Reference Hildebrand, Bickel and Alexa23] attempt to convert 3D structures into a set of simplified and fabricable planar polygons connected by interlocking planar pieces. These ideas are developed by building an interactive system where users can have access to real-time feedback by incorporating structure optimization and analysis [Reference Schwartzburg and Pauly10]. Most of that work employs a planar interlock mechanism to implicitly render the design due to its easy manufacturability and assemblability. This interlock mechanism constrains the achievable design space of furniture. Though this method can generate arbitrary solid geometries, it requires dense interlockers which may consume massive materials and cause material waste [Reference Sass24]. Recently, automated architecture proposed a similar modular strategy to create architecture by using prefabricated plywood building blocks, which can be assembled into a home, office, or coworking space [Reference Claypool, Retsin, Garcia, Jaschke and Saey25]. However, these plywood building blocks require extensive engineering and complicated installation instruction, which limits it within domain experts. Similarly, Groenewolt et al. have presented several methods to enable the computational design of large-scale architecture [Reference Groenewolt, Schwinn, Nguyen and Menges26]. Nonetheless, the fabrication and assembly of these components require domain experts.

Our proposed system makes use of an extensible collection of planar joints to connect different planar elements to generate furniture designs. Similar to the interlocking slots, these joints are rapidly fabricable due to their 2D geometries. A variety of furniture designs have been enabled in this paper. In addition, the design space is potentially extendable thanks to the abstract design scheme. Moreover, other planar joints can be incorporated into our system to enable users to create more different types of furniture.

2.3. Personal fabrication and assembly

Based on the continued development of democratized tools [Reference Landay27, Reference Torres and Paulos28, Reference Umetani, Igarashi and Mitra29, Reference Schulz, Sung, Spielberg, Zhao, Cheng, Grinspun, Rus and Matusik30], it is expected that casual end-users will play an important role in designing and creating their own products in the future. Several researchers have recently introduced systems for personal fabrication. Spatial Sketch [Reference Willis, Lin, Mitani and Igarashi31] allows users to sketch in a 3D real-world space. This system realizes the personal fabrication by converting the original 3D sketch into a set of planar slices realized using a laser cutter and assembled into solid objects. Similarly, users can create customized plush toys [Reference Mori and Igarashi32] and chairs [Reference Saul, Lau, Mitani and Igarashi21]. These systems convert designs from 3D geometries to a series of planar pieces to simplify fabrication. Postprocessing assembly of varying complexity is needed to complete the manufacture. Our work similarly approaches personal fabrication through the use of planar joints which are instinctively easy to assemble, minimizing the need for careful positioning or hardware-based attachments.

3.1. Design workflow

As shown in Fig. 1, our system assists inexpert end-users in handling the whole creation process of flat-pack furniture, from design, through fabrication, to assembly. More specifically, with a furniture model in mind, users can follow these four sequential steps (Fig. 1(b)) to achieve their designs: (1) components selection; (2) parameter constraint; (3) connection definition; and (4) fabrication specification. To demonstrate the process, we use a very simple model (two rectangles connected perpendicularly along an edge—perhaps serving as a bookend—as shown in Fig. 2) as an example with its script-based interface (see Fig. 3). In the first step, casual end-users select two predefined parameterized rectangle components from an existing library (Fig. 2(a), and lines 8–10 in Fig. 3) to match their conception of the designs (experts can create their own components, see Section 4.1.1). Then, they constrain the selected components’ geometries, that is, widths and lengths (Fig. 2(b), and lines 16–21 in Fig. 3). In the third step, users specify the design by defining the connections with connected edges and angle (Fig. 2(c), and lines 23–27 in Fig. 3). In the last step, given a description of available fabrication specifications (e.g., tools, materials), our system will automatically produce manufacturable specifications that capture dimensioned geometries, joint types, and joint patterns into a 3D rendering file and a 2D fabrication file (lines 32–36 in Fig. 3). The 3D file can be used to visualize the design. The 2D file can be directly sent to 2D fabrication machines (e.g., laser cutter); thus the resulting fabricated components could be assembled into the desired physical models. Users can repeat steps 1–3 to build designs of arbitrary complexity. Also, hierarchical composition (see Section 4.2) could also be harnessed to create sophisticated furniture models. It is worth noting that we represent all components as 2D polygons since they are defined as planar geometries in our system and only substantialized as 3D structures when fabrication specifications (especially material and its thickness) are resolved.

Figure 1. Workflow for making furniture. We use a picnic table as an example. (a) Conception of designs; (b) Design in our system. Users select components (or designs) from our library, constrains their dimensions, define connections of selected components (or designs), and input fabrication specifications (e.g., materials and corresponding thicknesses); (c) 2D fabrication. The output 2D fabrication file is patterned on planar materials (e.g., plywood, 3 mm) by 2D fabrication machinery (e.g., laser cutter); (d) Assembly. Furniture is built with easy-to-assemble joints through interference fit.

Figure 2. An illustration of a typical design process in our system. (a) Users select two predefined rectangle components from our library; (b) Users specify the dimension of each component (e.g., widths and lengths of the rectangles); (c) Then they define the connection between the two rectangles at selected edges with an 90° angle.

Figure 3. The interface of our proposed system, showing how we connect two rectangle components at selected edges with an 90° angle, as presented in Fig. 2.

By leveraging the knowledge of domain experts, our system can release novice from tedious engineering details and underlying system implementation, and instead focusing on functional design of desired furniture by following the above-mentioned steps. For experts, our system has also provided the freedom to (1) create their own new basic components by defining polygons (needs to specify parameters and ports as shown in Fig. 5), (2) to define fabrication specifications, like kerf and amplitude of interference, and (3) to add new joints. It is worth noting that all the three advanced operations are only introduced for completeness of presentation and limited to experts; novices only need to design and build new furniture by composing existing components using the four step process (component selection, parameter constraint, connection definition, and fabrication specification).

Figure 4. Joint collection. (a) A finger–finger joint for an edge–edge connection; (b) A finger–hole joint for an edge-face connection; (c) A slot–slot joint for a face–face connection; (d) A flap joint for edge–edge connection [Reference Zheng33]. (e) The fabrication pattern of a cable-driven joint. The relaxed and bent states of the joint are shown in (f) and (g), respectively. It is worth noting that cables are needed for both flap joints and cable-driven joints and linear motors are required for cable-driven joints.

Figure 5. An example of parameterized abstraction. (a) Rectangle component geometric diagram with parameters labeled; (b) Program implementation of a parameterized rectangle class in Python script in our system.

3.2. Design space

In our system, connections represent the spatial relationship of the two connected components, while joints are physical implementations of the corresponding connections. Theoretically, our system can design furniture with arbitrary complexity according to users’ input due to the availability of our connection architecture. Despite the arbitrary complexity of designs allowed in our system, the design space is confined by the physical limitations of the joints to ensure the manufacturability of the resulting furniture. Currently, we employ three types of joints, that is, finger–finger joint, finger–hole joint, and slot–slot joint (as shown in Fig. 4(a)−(c)), to implement corresponding connections. These joints are instinctively easy to assemble, minimizing the need for careful positioning or hardware-based attachment for casual end-users. These three types of joints are only applicable to 90-degree connections; thus, furniture with non-90-degree joints can be designed in our system but are not valid for assembly. However, this limitation can be removed as long as we can find available joints that can be implemented to fix two connected components at a specific angle, and easy to be assembled by novice users. For example, flap joints can be a good candidate as demonstrated in Fig. 4(d). Likewise, other types of joints can be implemented to expand the design space to enable more functionalities of the resulting models.

Our system is currently specialized for furniture designs with single-type raw materials with uniform thickness. However, our system has the potential to accommodate multiple materials with various thicknesses. For example, we can add two additional parameters, that is, material type (including Young’s modulus, Poisson ratio, and so forth) and thickness, into the component class as described in Section 4.1.1. Consequently, our system can modify the length and width of the fingers of joints.

4.1. Parameterized abstraction

The 3D geometries of flat-pack furniture in our system are defined as a composition of connected components. In traditional furniture design process, creating a piece of functional furniture design can be rather challenging since users may need to adjust many parameters with complex dependencies while maintaining the manufacturability and assemblability. Even with the aid of some CAD tools, users may still experience great difficulties due to the lack of in-depth understanding of CAD software and the manufacturing process.

In order to allow casual end-users to design furniture with ease, our system largely simplifies the design process into an abstracted function-based manner. To achieve this abstracted design, we parameterize all elements in furniture creation process, including components, connections, designated furniture models, and fabrication specifications. Therefore, we introduce the parameterized abstraction of components, connections, and furniture models in following paragraphs.

4.1.1. Components

Representation

As mentioned before, components are represented as 2D polygons. Therefore, in our system, a component’s fabrication-related parameters, for example, material type and its thickness, are not defined until specific fabrication and assembly methods are determined by users in the final steps of the design process. At that time, these abstract components are implemented automatically as 3D ingredients according to the input fabrication specifications. More details about how we represent components are described in the next section, where we use a rectangle as an example.

Components in our system fall into two categories: basic components and hierarchically composed components (later introduced in Section 4.2). Our system already comes with a set of predefined, commonly used polygon components, such as rectangle, trapezoid, n-side polygon, and so forth. After abstract parameterization, every component in our system is programed as an object instantiated from a corresponding component class, and represented as follows:

\begin{equation*} \textbf {Component}\;\left(para\,\textbf {1}, para\,\textbf {2}, \ldots,para\,\textbf {i}, \ldots, para\,\textbf {n}\right) \end{equation*}

where Component is the component class name and $para\,\textbf{i}$ is the ith predefined parameter of the component. To instantiate a component object of the corresponding component class, users only need to specify the parameters.

Construction

Figure 5 uses a rectangle component as an example to demonstrate how we define a component class in our system (each component is an instance of the component class). Firstly, we need to define the parameters of the component class (lines 2–3), which are the length $l$ and width $w$ of the rectangle in this case. Then, we specify the outer vertices of the component class whose order follows the right-hand rule so that the front of the component is facing the out-of-page direction (line 5). Lastly, we set a series of interfaces to the component class, which are some ports that can be used to connect with the interfaces of other components. In this example, we set the edges of the rectangle as interfaces with the name $b$ , $r$ , $t$ , and $l$ . Thus, we have a rectangle class with four interfaces and two parameters. It is worth noting that we have specified the angle between the length $l$ and width $w$ to be 90 degrees due to the definition of a rectangle shape. Otherwise, we could add another parameter, angle $a$ , to specify a parallelogram component, which is a super-set of the rectangle class. In the same manner, we can follow this recipe to build arbitrary 2D polygon classes.

Experts or developers can also define their own custom components following the same workflow illustrated above, which only requires them to specify the parameters, vertices, and interfaces of the components. Customizing components is one way to define desired components when they are not available in our library. This base-level component creation is typically not necessary, though, and presented here for completeness. More commonly and more intuitively, users can harness hierarchical composition (see Section 4.2) to piece together elementary components into new complex component. For example, users can obtain a new “L” shape component by combining two rectangles together along edges. Thus, we theoretically only need a few basic polygons, that is, triangle and rectangle (though it can also be built from combining two right triangles). Therefore, the number of initial designs in the library is not critical; however, it is easier and faster for the nonexpert users to create their design if there are more available basic designs so that they can directly pick-and-place components instead of creating every component from scratch. It is worth noting that experts or developers are allowed to define components with fewer parameters, called meta-parameters, by adding some geometric constraints to the original parameters. Thus, they are not exposed to the enormous design parameters when the design becomes complicated. For example, we can only select the length of the rectangle as the manipulable metaparameters and geometrically constrain its width as a half of its length to create a component with a fixed aspect ratio.

4.1.2. Connection

Representation and construction

Connections in our system are also parameterizedly abstracted. Once a connection has been defined, we build an associated connectivity item to store all its information that is efficient to embody the connection physically in following operations. Later, the abstract connections will be implemented physically to actually join connected components. There are in general two different methods to specify connections between components: (1) users can create connections in a global coordinate frame or (2) in a local coordinate frame. These two methods have their own advantages and disadvantages. In this project, we choose to use the latter so that the connection is defined referring to the local coordinate frame of the existing component instead of the global coordinate frame of the design. In this manner, the connection between the two connected components can be defined easily since the connection itself is the local relationship of the two components. Otherwise, the global design frame would post challenges to the implementation of joints that must accommodate arbitrary connections. This requirement would complicate the structure of designs and may need extra accessories for joints, which would increase the difficulty of fabrication and $\unicode{x2460}$ assembly.

A connection is represented by a directed line in a connectivity graph of a furniture model. Here, we use a computer desk, as shown in Fig. 6 as an example. In the figure, connection ( $\unicode{x2461}\xrightarrow{}\unicode{x2460}$ ) denotes that component $\unicode{x2461}$ is connected to component $\unicode{x2460}$ at some interfaces. In the graph, the edges of the line represent the connected interfaces of corresponding components. The direction specifies the way we specify the connection. Note that ( $\unicode{x2460}\xrightarrow{}\unicode{x2461}$ ) is different from ( $\unicode{x2461}\xrightarrow{}\unicode{x2460}$ ); they may represent the same spatial relationship with specific parameters in the 5-tuple. However, the way we specify a connection does not indicate the assemblability and the order of the assembly. More explanations would be found in the following paragraphs.

Figure 6. Representation of a furniture model. We take a computer desk as an example. Components labeled as circled number, for example, $\unicode{x2460}$ ) and connections as boxed number, for example, $\square \!\!\!1\,$ . (a) 3D model of the desk; (b) Connectivity graph of the desk with connections represented as directed yellow lines, whose directions indicate the connection orientation.)

Finding a proper way to specify the abstracted connection between two components can be nontrivial because it needs to be accurate, concise, and intuitive for users, while being able to express all possible spatial relations. In our system, the connection is specified abstractly as a 5-tuple. For instance, when component $C_A$ is connected to $C_B$ , we can call the constructor to define the connection:

\begin{align*} \textbf{Connection}\left(\:\left(\textbf{C}_{\textbf{A}}, I_{A}^i\right), \left(\textbf{C}_{\textbf{B}}, I_{B}^j\right), P_{A}, P_{O}, P_{R}\right) \end{align*}

where $C_A$ and $C_B$ are two connected components. In this expression, the first component $C_A$ is connected to the second component $C_B$ . In this connection, $C_A$ is named as the connecting component and $C_B$ is named as the connected component. Thus, this connection could be shortly annotated as $\textbf{Connection}(A \xrightarrow{}\textbf{B)}$ . The sequence of the two components matters. $I_{A}^i$ and $I_{B}^j$ represent the selected interface $i$ of component $C_A$ and the interface $j$ of component $C_B$ . These two selected interfaces will be connected together. $P_{A}$ , $P_{O}$ , $P_{R}$ represent the alignment, offset, and rotation of the connection. The value of $P_{A}$ is either “front-front” or “front-back.” “Front-front” means that two connected components have the same orientation while “front-back” indicates their orientation is opposite to each other. $P_{O}$ is a 3-tuple, specifying the 3D offset vector that component A (connecting component) should travel in accordance with. $P_{R}$ is also a 3-tuple, defining how component A along with its local coordinate system is rotated around its own x, y, and z axis, respectively. For example, in Fig. 6(b), the connection between component $\unicode{x2460}$ and $\unicode{x2461}$ can also be described as $\textbf{Connection}(\unicode{x2461} \xrightarrow{} \unicode{x2460})$ .

Using this 5-argument connection constructor, we can represent any possible spatial relations between two components while providing users an intuitive and easy way to state connections. Here, we will illustrate this connection constructor in detail (see Fig. 7). For instance, $\textbf{Connection}(\:(\textbf{$A$}, t), (\textbf{$B$}, b), front-front, (v_x,v_y,v_z), (\theta _x,\theta _y,\theta _z))$ can be visualized as in Fig. 7(b). From the connection constructor, we know that interface $t$ of component A is connected to interface $b$ of component B. Since the alignment is specified as “front-front,” the orientation of both faces facing up results in a temporary position as the left graph in Fig. 7(b). x-y-z is the coordinate of component B being set as the global coordinate for this connection while x’-y’-z’ is the local coordinate of component A, fully overlapping with B’s. Then a 3D offset vector $(v_x,v_y,v_z)$ is applied to component A (as the middle graph shows) and followed by a 3-Axis rotation $(\theta _x,\theta _y,\theta _z))$ to change the orientation of the component (e.g., (90,0,0) represents a 90 $^\circ$ rotation about x axis as in the right graph in Fig. 7(b)). The other case with “front-back” alignment is also presented in Fig. 7(c). Though rather simple and intuitive, the connection specification process could be greatly simplified with a graphic user interface later on.

Figure 7. Connection visualization. (a) Component A and B with their interfaces labeled and original coordinates specified; Connections with “front-front” alignment (b) and “front-back” alignment (c). Left: Alignment defined; Middle: 3D offset; Right: 3-axis rotation.

With these well-defined connections between components, each furniture design can be organized into a connectivity graph (Fig. 6(b)). Thus, the position of each component can be computed by tracing this connectivity graph. For example, we can compute the position of component $\unicode{x2461}$ with the $\textbf{Connection}(\unicode{x2461}\ \xrightarrow{} \unicode{x2460})$ and the position of component $\unicode{x2460}$ (which is known). In the same manner, we can calculate the positions of the rest of the components accordingly. It is worth noting that we can have two different expressions to represent the same spatial connection. In other words, these two different expressions are interchangeable and depict the same spatial relationship. For example, $\textbf{Connection}(\unicode{x2461} \xrightarrow{} \unicode{x2460})$ is different from $\textbf{Connection}(\unicode{x2460} \xrightarrow{} \unicode{x2461})$ . However, they characterize the same 3D relationship that two components are connected at the edge orthogonally (see Fig. 6).

Physical implementation

Though parameterized abstraction can greatly facilitate the design process, the connections need to be implemented physically to actually join connected components when it comes to manufacture. In this paper, we decide to use planar joints to embody the connections to reduce the difficulty of fabrication and assembly. Thus, users do not need to go through the tedious assembly process with system-defined joints [Reference Schulz, Shamir, Levin, Sitthi-amorn and Matusik19].

To enable the manufacturability of furniture designs, joints must be added at places of intersections. However, for casual end-users, determining and drawing proper joint patterns can be a liability, even with the help of some design software (e.g., AutoCAD, Solidworks, UG, Inventor, Inkscape, and so forth). Our computational design tool will automatically add one of the three types of joints (as shown in Fig. 4(a)−(c), respectively) according to specific abstract connections. More details for these three types of joints can be found in Appendix A.1). The joints that we introduce here have the following two advantages: (1) they can be easily fabricated using modern 2D manufacturing tools (e.g., laser cutter, waterjet, and jigsaw); (2) are handy to assemble even without skilled craftsmanship.

Theoretically, any joints, especially those that satisfy the above requirements, can be incorporated into our system since the joints are merely the physical implementation of abstracted connections [Reference Tian, Sterman, Chiou, Warner and Paulos34]. For example, the flap joints [Reference Zheng33] (see Fig. 4(d), not implemented in our system) could potentially be adopted to achieve edge–edge connections. Thus, the system would generate holes for connections instead of finger patterns to implement joints. However, this type of joint requires more labor and skill to assemble. Similarly, fasteners (e.g., nails) or adhesives (e.g., glue) can be used in additional types of joints; this would increase the difficulty of assembly as well [Reference Umetani, Igarashi and Mitra29]. It is straightforward to extend our library of joints to expand the design space, though care must be taken to balance against the capabilities of a proposed user.

In addition, active joints could be possible to realize connection implementation, which leads to active devices, such as active furniture and robots. As a proof of concept, we create cable-driven joints to allow resulting devices to have angular movements. For example, we connect two rectangle components with a cable-driven joint, as shown in Fig. 4(f) and (g). The fabrication pattern is shown in Fig. 4(e). By adding a lattice pattern [Reference Guy35] (more details can be found in Section A.2) along the connected edges of the two rectangles, a flexible joint is formed to allow angular movements between two connected components. A linear motor with its shaft is tied to the left rectangle using a cable, is then attached to the right rectangle, as shown in Fig. 4(f). The back-and-forth movement of the shaft of the motor will change the angle between two components (see Fig. 4(f) and (g)). Presumably, this type of joint can be used as living hinges for doors of furniture or movable joints of robots.

In this paper, joints are mainly assembled through interference fit—also known as a press fit or friction fit—a form of fastening between two tight-fitting mating parts that produces a joint held together by friction from a compressive normal force. As the amplitude of interference (amount of geometric overlap between mating parts) grows, both the deformation of the joint material and the difficulty of assembly increase, which means optimal interference amplitudes are needed to be calculated based on the fabrication specifications. Our system can automatically output the optimal profiles of joints once the fabrication specifications (e.g., materials and fabrication machines) are defined by users. More details could be found in Appendix A.1.

4.2. Hierarchical composition

4.2.1. Design principle

To enable users to build complex furniture designs with ease, we harness function-based hierarchical composition, which allows users to recursively build up to the desired complex furniture constructions from relatively simple existing designs. This means we organize all the parameterized data of the furniture design into a hierarchical tree, whose structure is defined by how we recursively create the furniture. In this manner, functional models at any level could be treated as components to specify higher level furniture designs. For instance, to build a bunk bed as illustrated in Fig. 8(d), instead of building the whole piece from scratch, users can simply select these existing designs, a computer desk, a bed, and a ladder (as shown in Fig. 8(a)−(c), respectively) to be composed together. The computer desk, bed, and ladder can be further decomposed into elementary components (e.g., rectangle). Therefore, the $i_{th}$ level hierarchy $M^{i}$ of a hierarchically composed model can be written as:

\begin{equation*}M^{i} = \left(\left\{Component^i\right\}, \left\{Connection^i\right\}, \left\{Constraint^i\right\}, \left\{Interface^i\right\}\right)\end{equation*}

where $\{Component^i\}$ is a set of “basic” components consisting of the hierarchical design in this level. Each “basic” components in this set can be a composed furniture design or an elementary component. $\{Connection^i\}$ is a set of connections specifying how the “basic” components are connected, $\{Constraint^i\}$ is the set of parameters constraining model $M^{i}$ , and $\{Interface^i\}$ is the set of interfaces of the new hierarchically composed model $M^{i}$ .

Figure 8. A illustration of hierarchical composition with a bunk bed. Three “components,” that is, a computer desk (a), a bed (b), and a ladder (c) are composed into a bunk bed (d). Each “component” itself is a furniture design with certain functionalities. The connectivity graphs of three “components” are also pictured in (e), (f), and (g). The final connectivity graph of the bunk bed is also directly composed of all “components” H).

To further demonstrate how we implement our system, we use the above mentioned bookend (see Figs. 2 and 3) as an example. Each rectangle (A and B) is an instance of the Rectangle class, which is defined in Python. After parameter constraint and connection definition, we can obtain a composite structure—two rectangles connected perpendicularly along an edge. Due to the hierarchical architecture of our system, this composite structure can itself be used as a component, ConnectionJointBuilder, by saving it as a .YAML file into the library (see lines 29−30 in Fig. 3). This new class of component, ConnectionJointBuilder, inherits the properties from the composite structure with two rectangles connected perpendicularly along an edge. Recursively, we can use this hierarchical composition strategy to build furniture with arbitrary complexity with ease, as shown in Fig. 8.

4.3. Coordinate placement

To place each component in a global coordinate system and find the places of intersections to add proper joints, we employ a coordinate placement algorithm. At the design stage, we require users to define connections between components. However, these connections only specify the relative spatial relation, which is not necessarily the positions at which joints are placed. Therefore, we use an intersection autodetection algorithm (see Section 4.4) to place necessary joints based on the derived spatial relation to finalize the design for manufacturing and assembly. Having derived the connectivity graph representing the furniture designs, our system can perform a traversal on the graph to recursively compute the 3D coordinates of each component following Algorithm 1, which will later be used to build up the 3D model.

Algorithm 1. Compute the global 3D coordinates for every component of the component set {C} of a design based on the defined associated connections

Initially, each component is placed within its own local coordinates as defined by the user as in Fig. 5(a). Our goal is to find each component’s 4 by 4 transformation matrix, $T_{global}$ , which transforms the homogeneous coordinates of the original components into a global 3D coordinate space as per the connections. To do so, we adopt the recursive Algorithm 1. The input of the function consists of the component set $C$ , a 4 by 4 transformation matrix $T_{global}$ that represents its global coordinate. The algorithm randomly selects a component $C_i$ as a starting point and recursively find the coordinate of all components connected to it. This step starts by storing the transformation matrix as an attribute of the component. Then, for each connection, for example, $\textbf{Connection}(A\xrightarrow{}B)$ , that involves this component, if this component $C_i$ is connected to component $C^B$ (i.e., $C_i=C_B$ , line 5), we can find the relative transformation, $T_{relative}$ , through the function, $FindRT(\textbf{Connection}(A\xrightarrow{}B))$ , between them and times the global transformation matrix of $C_B$ (= $C_i$ ) to obtain the new global transformation matrix $T_{global}^{'}$ to run the next iteration until the 3D coordinates of all components are calculated (lines 6–8). Another execution will be made for $C_A$ . If $C_i$ is connecting component $C^A$ (i.e., $C_i=C_A$ , line 9), then we should find the inverse of the relative transformation between them and times the global transformation matrix of $C_A$ (= $C_i$ ) to have new global transformation matrix $T_{global}^{'}$ to run the next iteration (lines 10−12).

4.4. Intersection autodetection

After the coordinate placement phase illustrated in Section 4.3, we derive the global 3D coordinates for all components, but the design is still by no means manufacturable. In other words, we need to detect the places of intersections and add proper joint mechanisms to finalize the model as well as to ensure its manufacturability. By performing an automatic intersection detection, we release users from the burden of specifying all places of intersections with connections explicitly. More specifically, using the connection constructor, user can easily build the 3D model for their designs with a minimal number of connections, which may not include all necessary intersections. Then our algorithm can automatically handle the intersection detection to guarantee the manufacturability and functionality. This algorithm is particularly useful for hierarchical composition because it is very challenging for casual end-users to specify all necessary connections thoroughly due to the geometry complexity. Hence, it help users to focus on design in a function-based manner.

In this section, we use a reading desk, as shown in Fig. 9(a), as an example to illustrate the algorithm. To design such a reading desk with 11 components and 17 joints, users only need to specify 10 connections (from to in Fig. 9(b)) with other necessary intersections (or joints) (from (11) to (17)) inserted automatically by our algorithm. For instance, a joint is automatically added between component $\unicode{x2461}$ and $\unicode{x2467}$ while there is no connection defined by users. Moreover, our algorithm can help to merge coplanar components to reduce the complexity of design and assembly. For example, component $\unicode{x2460}$ and $\unicode{x2463}$ , originally connected by connection , are merged into a single component.

Figure 9. An illustration of intersection auto-detection. Components labeled as circled number, for example, $\unicode{x2460}$ ) and connections as boxed number, for example, $\square \!\!\!1\,$ . (a) 3D model of a reading desk; (b) Connectivity graph; (c) Fabricated and assembled (scaled) reading desk with 3 mm plywood. Note: This desk can also be built through hierarchical composition, which will be discussed later in Section 5.2.

In the following two sections, we will explain the intersection autodetection algorithm in detail with which divided into two parts: coplanar faces merging (lines 1–6), intersection segments searching (lines 7–16), and joints inserting (lines 17–27).

Algorithm 2. Find all necessary intersections and joints of a designed model composed of a set of components {C} and specified connections

4.5. Output and fabrication

Each furniture design in this system is an instance of a common parent class, stored as an executable Python script (see Fig. 3). At execution time, running this script places all the components into a final 2D design file (.SVG or .DXF)—as shown in Figs. 4 and 15—to be sent directly to the 2D cutting machine (e.g., laser cutter or waterjet) or printed onto a pattern for hand cutting. During this process, the fabrication specifications are considered, and joints are selected and rendered in the final files. Components are placed separately from each other to avoid overlapping. However, we can manually rearrange components (or even divide components into two separate files) if the cutting space cannot accommodate all components. In addition, we need to manually split (at a position away from the original edge for connection) and fabricate long pieces that do not fit within the cutting space; then combine split pieces back together by using coplanar finger–finger joints.

To enable easy and fast fabrication, we adopt planar joints that can be cut through the 2D cutting process. A typical manufacturing specification is a material with its corresponding thickness. For finer grained expert control, additional fabrication specifications could adjust laser cutting kerf and desired magnitude of friction-fit interference. A specific joint pattern is chosen appropriate to these specifications (see Section A.1). To ensure successful manufacturability, our system automatically evaluates some geometrical considerations about the connected components and corresponding joints: (1) the dimension perpendicular to the connected edge of components must accommodate the finger length and (2) the dimension along the connected edge of components must accommodate sufficient finger widths. More details are given in Section A.1; our system prompts warnings when these conditions are not satisfied.

In this way, our system as mentioned above assigns each component a unique manufacturing specification that dictates how the design specifications translate to real-world realizable output files. These 2D files are also available for paper cutters (e.g., Silhouette CAMEO 2) and CNC router ( via conversion of the .DXF files to .IGES or .G-code). Our system also can render 3D models (.STL files, see Figs. 6(a), 8, and 9(a) for visualization to assist design process. If necessary, these .STL files can be used as inputs of a 3D printer to directly generate 3D mockups. This complete process is validated through several successful designs (see Figs. 11, 13, and 14).

Figure 10. Examples of assemblability testing by using acrylic sheets (thickness, 1.5 mm) as the low-cost substitutions of lumber. The components that are nonassemblable are in red color.

Figure 11. Furniture design examples using our system. The numbers of components, available design parameters, connections, and joints of each design are labeled. For design parameters, the structure-preserved values are calculated after some constraints are added to preserve the structure of the designs while the maximal values are included in brackets.

Figure 12. An illustration of the flexibility of modeling process in our system. Components labeled as circled number, for example, $\unicode{x2460}$ ) and connections represented by boxed number,for example, $\square \!\!\!1\,$ . Components from different furniture models are differentiated by color. (a) Opposite connection direction but the same ordering; (b) Different connection ordering; (c) Hierarchically composed from two different designs; (d) Hierarchically composed from three models.

Figure 13. An illustration of design manipulation after a rocker chair has been composed in our system. Eight metaparameters of a rocker chair are labeled (a). A bunch of variants of the rocker chair are created by manipulating the metaparameters. These variants included a long bench for the side of the pool (b), a tall chair for bar (c), and a rocking bed (d). Other wildly modified rocker chairs are shown in (d)–(m) to demonstrate the vast design space. Several scaled chairs are fabricated and assembled (n).

Figure 14. Compound furniture designs hierarchically composed from existing furniture models. (a) A collection of simple furniture models, including a vertical shelf, a horizontal shelf, and a simple table. Six compound furniture models, composed from the aforementioned simple designs are displayed from (b)−(g). They are a TV console (b), a study desk (c), a multiuse shelf (d), an over-the-toilet storage (e), a corner workshop bench (f), and a dresser (g), respectively. Several other compound designs are also presented in (h), (i), and (j).

4.6. Validation and assembly

Though some other design tools simplify the design process, the assembly processes still require a lot of experience, which inhibits novice users from creating their own custom furniture (see Table I). Our solution for this issue is to adopt planar joints that are realized exclusively through the single 2D cutting process and the easily assemblable planar joints as mentioned in Section A.1. These planar joints are easy to align due to the particular finger configuration and are easy to assemble through interference fit without the requirement for extra carpentry skills, tools, or materials.@@

To validate the assemblability and generate an assembly plan of the resulting furniture, we currently provide users a testing process with low-cost substitutes (e.g., copy paper or acrylic sheet) to build small-scale prototypes; this yields intuitive tactile feedback for novice users, without requiring them to map digital/computational representations of the physical assembly steps. Here, we use two furniture designs that have been shown before in the paper as examples. For instance, the original design of the reading desk is not assemblable due to the interlocking between components $\unicode{x2464}$ (or $\unicode{x2465}$ ) and $\unicode{x2468}$ as shown in Fig. 10(a) and (b). By modifying the geometry of components $\unicode{x2467}$ and $\unicode{x2468}$ into convex shape, we obtain an assemblable reading desk as shown in Fig. 10(c) and (d). Also, by experimenting with the prototype, we can explore and find some valid assembly plans. One of the valid assembly plans is to (1) install components $\unicode{x2464}$ − $\unicode{x2467}$ onto $\unicode{x2468}$ ; (2) add $\unicode{x2461}$ and $\unicode{x2463}$ to the assembled structure; (3) finalize the assembly by fixing $\unicode{x2460}$ and $\unicode{x2462}$ onto the designed position. Also, it is possible to over constrain the design due to redundant connections. As shown in Fig. 10(e) and (f), the two connections between components $\unicode{x2460}$ (or $\unicode{x2462}$ ) and $\unicode{x2464}$ (or $\unicode{x2463}$ ) of the picnic table are incompatible, which makes the design nonassemblable. By removing one of them, the table can be easily installed (see Fig. 10(g) and (h)). Similarly, this validating method can be used to explore the assemblability and assembly plan for other furniture designs due to the low-cost and rapid prototyping provided by our system.