"It has relegated architects to producing representations of architectural intent while handing over the responsibility of means and methods of making to builders. With recent advances in digital technologies, this relationship is once again becoming entangled." Here, I present two computational design projects I made - regarding ** Precision** and

**of today's architectural practices - that fuse the roles of architect, engineer, and craftsman.**

*Recursion*## Precision

This project focuses on curvature and *continuous precision*. I abstract a G2 continuous curvature from raw Electrocardiography (ECG) curves and turned it into an assembly that could self-locked when loaded in one direction.

Then I started to refine and abstract the curve, beginning with converting the noisy curve into G0 straight polygon lines, and match new G2 control points on those lines or their extension lines. To avoid straight none-curvature lines in the final abstraction, I didn't simply cut the corners and blend the lines. In addition to that, I didn't directly use intersection points as control points which could cause a great loss of information.

Then I started to laser cut the first set of assembly models and check if they could be successfully loaded when press on the side. The result was positive. Thus, I continued to simplify and made the final assembly curvature.

### 2D Assembly

When implementing the curve to the final 2D assembly, I opened a *small gap* on the “shield” side to make sure the structure can be effortlessly assembled on the same plane. Then, two parts will “bite” each other and fixed when pressing on one side, while easily open when loaded on the other side.

### Fake Circle

You can never draw a perfect circle with a control-point curve, but an infinitely close one. When control points n = 32, the radial error in the approximation will be about 0.0273% of the circle’s radius, which is, under tolerance, the same as a real circle.

Imagine made out of solid materials, when lifted, because of gravity, the circle will always be on the tendency to expand. I think I find a perfect way to deploy this “one-side-load” assembly system…

Rotating the polygon for 30 degrees (n = 12), and connecting two sides, I created a front-to-end recursive system in which every part can connect and feed each other in the circle.

Ideally, parts will finally form a fixed and sturdy ring. However, due to the sturdiness and friction factor of the material used for printing, the physical model finally survived to 7 and… crashed.

## Recursion

This project focuses on recursive balance, where digital software computes and solves physical problems that are nearly impossible for human beings to calculate. The goal is to make the *Center of Mass* of the whole object right above (or below) the hanging point with dynamic modeling.

### All Start with Points

The whole challenge is based on the position and relationships between 9 points (6 moving points and 3 bases). At the beginning of the challenge, a `Random()`

function is implemented to shift the points vertically to make non-copyable different initial settings. The COM (Center of Mass) starts changing from this phase.

Then the computation steps into the recursive part. The whole computation is inside Grasshopper / HoopSnake function, I also wrote a few python elements to meet some other needs.

The function will first compare the six angles between COM-to-Goal-Point Vector with six other vectors pointing to the direction of Moving Points. As mathematicians proved for us a long time ago, the smaller the sin(α) (α is the angle) is, the greater the particular vector will affect the main vector. So did I calculate the responsive moving distance - the smaller angle is, the longer to move. After each move, COM will come closer to the goal point, and the moving directions and distance will adjust each time based on the latest computation.

*First Two Rows: same Goal Point, random heights*

*Last Two Rows: same arbitrary height, different Goal Points*

After several sample moves shown above, I tried to understand the effect caused by the vertical height and the position of the Goal Point. Obviously, the Goal hanging point affects the whole system the most.

### Experiment #1: Move Only One Level of Points

The whole moving-point system can be divided into two sets of points: Inner Lower Level (1), and Outer Higher Level (2). In this extra experiment, I tried to move only one set of points, and see how will the final form change.

### Experiment #2: x + y + n

The HoopSnake Recursion is using “x + y + n” (x: Feedback from HoopSnake, y: Weighted Moving Distance, n = 0 initially) as a necessary component to compute the future feedbacks. And during this experiment, I’m going to reveal the relationship between n and the final object’s formation.

### Experiment #3: Recursively Move Twice

Since the whole geometry is centra-symmetric, there are actually only two equivalent areas of Goal Point, and the rest are just repeating. However, as this is dynamic modeling, why not try to move Goal Point at the end of the first Recursion and let the solver run a second round? In this way, 22 more different situations are created.