Hi. I’m Keunwoo Park.
While I interned at Hasso Plattener Institute
I worked on laser cutting.
You can see a user assembling a chair model.
Here, the user wants to insert a leg piece
but picks up an incorrect piece, and recognizes that it does not fit.
FoolProofJoint solves this issue by making pieces identical,
thus interchangeable.
Second, it is possible that the user might try to assemble a piece
in the wrong orientation, causing the piece to not fit.
FoolProofJoint addresses this issue by making pieces symmetric.
Third, the user wants assemble the backrest here,
and there are two similar looking pieces.
However, one of them does not belong to the back rest, but it still fits there.
Subsequent pieces might continue to fit as well, producing a propagation error.
Resulting in a frustrating disassembly process.
FoolProofJoint addresses these assembly mistakes
by giving each joint pair a unique finger pattern,
which assures that incorrect pieces never fit.
FoolProofJoint is a software tool that
reduces risk of erroneous assembly of laser cut models
by means of custom joints.
The problem of erroneous assembly has been discussed in the field of manufacturing.
If humans assemble manufactured parts,
product designers need to design the parts so that they are easy to assemble.
This is known as Design for Assembly, or DFA for short.
Under the term DFA, many design principles have been proposed.
I will introduce one example that is related to FoolProofJoint.
Parts should be designed to prevent mis-assembly.
For example,
the square part should be assembled with the hole on the right side,
but it can be mis-assembled in a flipped orientation.
A notch on the part can prevent this kind of mis-assembly.
However, dfa is done manually, and is an expensive process.
This only makes it applicable for manufacturing.
FoolProofJoint, automatically applies DFA to one-offs.
In this project, we focus on laser-cut models.
Here are some examples that improve the assembly process of laser-cut models.
Roadkill points users to the matching pieces directly from within the 2D layout
reducing visual search and speeding up assembly.
And Daedalus in the dark laser cuts haptic paths in the plates
to make assembly instructions accessible to blind users.
FoolProofJoint introduces the concept of automated DFA
and applies it to laser-cut models to reduce assembly errors.
Now, I will talk about the 2-step FoolProofJoint algorithm.
In the first step, FoolProofJoint creates joints
in a way that maximizes interchangeability and symmetry in the model.
In the second step, FoolProofJoint prevent
by making joint patterns distinct when necessary.
Let’s start by looking at the first step in more detail.
This step is an optimization problem
and let me show you why that is the case by using a simple example.
Take a look at the cube model.
It would be ideal to make all 6 pieces interchangeable and symmetric.
But it is not possible to do this.
The reason is in the corners of the cube.
Only one piece can fill the room in each corner.
In this corner, the top piece is filling the corner.
A cube has 8 corners and
it is impossible to equally distribute them across its 6 pieces.
Therefore, there is no way to make 6 identical pieces.
The best solution is to create 2 sets of pieces,
which is the solution that you are seeing here.
If we take a closer look at the corner again,
you can see that its design can be described as
the order of the three pieces that are involved.
The top piece is extended all the way to the corner,
the right piece has a finger that only touches the corner,
and the left piece fills in the rest.
This is an abstract description of a corner as an order of three pieces.
Now let’s see how FoolProofJoint finds this solution.
FoolProofJoint starts by assigning primary corners.
It tries to fill the corners with as few pieces as possible,
which is the top and bottom piece filling all the primary corners.
Then, it assigns 8 secondary corners to
4 side pieces resulting in 2 corners on each piece.
After the primary and secondary corners are filled,
the remaining corners then become tertiary corners.
After the order of pieces is defined for each corner,
FoolProofJoint fills the remaining parts of the joints
with alternating regular patterns of fingers and cutouts,
finally creating these pieces.
Now, let’s look at this more elaborate example.
FoolProofJoint starts by finding pieces
that are interchangeable and rotationally
FoolProofJoint gives high priorities to the pieces
which have a shape with high interchangeability
and symmetry and they will be handled first.
Let’s see how this plays out for the legs of the chair.
The analysis of pieces resulted in these priorities.
FoolProofJoint thus first assigns primary corners
to the high priority piece.
Then it continues to assign secondary corners to the mid priority pieces.
In order to ensure the two pieces fills
the same number of secondary corners,
FoolProofJoint assigns one secondary and one tertiary corner
on the shared edge to each piece.
And again, FoolProofJoint fills the remaining parts of the joints
with alternating regular patterns of fingers and cutouts.
FoolProofJoint uses this heuristic to design joints for the entire model.
This is the result which is optimized for interchangeability and symmetry.
However, a problem remains.
These two joints are exactly the same and the pieces could be exchanged.
This is a problem because these two pieces look similar,
but they have slightly different sizes.
The similarity of these pieces makes it easy to confuse them by users.
As a second step of the algorithm,
FoolProofJoint solves this problem by making the confusing joints distinct.
I’m going to show you how it works.
First, FoolProofJoint finds pieces that have the same joint pattern
as they can be potentially mis-assembled.
In the chair model,
the backrest and the side pieces have
the same joint pattern with the front leg piece,
so they can be wrongly assembled instead of the front leg piece.
Next, FoolProofJoint only looks for the pieces similar to the correct piece.
To detect similarity between pieces,
FoolProofJoint uses a turning function proposed by Niblack and Yin.
Now, FoolProofJoint differentiates these two joints.
In this example, FoolProofJoint changes the joint on the front leg.
However, updating a single joint pattern can break interchangeability and symmetry.
To preserve these properties,
FoolProofJoint updates multiple joint patterns at once when needed.
For example, this is the joint that FoolProofJoint updated earlier.
FoolProofJoint updates the joint and the mating joint accordingly.
And it also updates other joint patterns to
maintain interchangeability and symmetry.
This is the final chair model that
FoolProofJoint produces after running both steps.
We conducted a technical evaluation.
We used 217 models from the Kyub repository.
For 97 % of the models,
FoolProofJoint produced a result that cannot be mis-assembled.
The 3% of models that could still be misassembled contained edges that were
too short to allow FoolProofJoint to create
varied joint patterns necessary for distinction.
For 65% of piece groups with the same shape,
FoolProofJoint succeeded at making all the pieces
in the respective groups interchangeable.
FoolProofJoint made 47% of pieces with a symmetric shape,
fully symmetric by providing them with matching joint patterns.
Please note that it is not possible to achieve a score of 100%
for the last two metrics
since making pieces interchangeable and symmetric is not always possible
as demonstrated by the cube example.
FoolProofJoint automates and applies design for assembly guidelines
to laser-cut models by making pieces
interchangeable, symmetric, and creating distinct joints.
While design for assembly is a tedious and expensive process
that has traditionally been reserved for manufacturing,
with FoolProofJoint,
we propose automating DFA thus
making it viable to apply it to personal fabrication.
I would like to thank my wonderful co-authors.
Thank you for listening.