## Dragons and Curves

Delving further into the world of the dragon curve, I think I should start by sharing the principal behind the code.

The dragon curve is a space filling curve that never crosses itself. It is based on a principal of folding a piece of paper and repeating the folds in the same direction. When you unfold the paper with the angles at 90 degrees, the dragon curve can be formed. The folds can be repeated an infinite number of times, with the curve arcing at a 45 degree angle. Here, I will refer to each repetition as iterations.

I varied the code and set up a table to document the results, ultimately choosing three codes to further in my design for a Konsthall.

In order to progress with the design, I chose the code variation M1 to explore spatially. I used the geometries of the curve to create forms at three different scales as an exploration from street to seat; the impact on the streetscape, the scale of the pillar and it’s possibilities as seating. I wanted to allow the dragon curve to be the prominent expression in the design so I allowed all the internal spaces to flow along the curvatures created, sinking into the ground and back up as a sectional flow through the space. The roof structure is set at 45 degrees in a rigid, linear grid format to contrast and strengthen the curves in the Konsthall. The next step would be to bring the dragon curve into the built environment through models.

## Peculiar forms of perpendiculars

Since the last task, I continued to develop how my code was creating tangents, perpendicular lines and rectangles along any drawn input curve. I became particularly interested in moving the tangents along the created perpendicular and then extending to intersect with the next generated perpendicular line. In some cases the lines could not intersect and I was using this generation to determine what spaces are enclosed or open.

After exploring different arrangements of spaces, walls and circulation, I started to look at how the plan could be translated to create dynamic spaces through the manipulation of the code, such as randomly generating walls or beams at the perpendicular lines. I also created an undulating and pulsating roof form that increases and reduces in height and length by a tolerance from its neighbour.

Developing this further I began to use the code to generate different systems within the generated form, which I would run one after the other. Firstly the layout of enclosed and open spaces would be produced along with the main walls. Then the input curve would shatter to allow me to generate partition walls between these spaces. Finally I would then use the code to produce the beams and then the roof structure.

The geometry of the input curve I used to generate an example proposal was to place my building within the centre of the site and to arrange the spaces around this curve to maximize the views of the site looking outwards. In return this would create an enclosure within the large exposed site. The generated spaces which did not enclose would be use as a route through the building but also the park to maximise engagement to passerby’s.

Below is an example of the one of the many unique generations I could create with the code and with different input curves. I used this drawing to take a snapshot and evaluate how the different systems work together and now I intend to explore the roof form and lighting further to see how it can create different spaces which could display work if different situations.

## The Parametric Venn Diagram

Since the last task, I had a look at re-ordering the code so that the circles are extruded first, and then performing a boolean on the cylinders. This has the benefit of more variety in the heights of the rooms, and more interesting 3D intersections.

Looking back at the site, I chose a boundary that had multiple paths leading into it, with the idea that when wandering along the site one can wander in and out of the konsthall. The generated paths are a combination of internal corridors and external paths, providing a sheltered route as well as the option to move outdoors between the clusters, like paths through the park.

The circles, which are still clearly visible in plan, provide an opportunity to further express the direction of the paths that generate them. By adding a linear structure to the roof, following the direction of one of the paths, a simple but interesting ceiling is created. Where the circles overlap, it creates a more intricate lattice.

The alignment of the roof structure makes the paths even more legible, and the roof provides an opportunity to bring natural light into the spaces.

## intersections & overlaps.

Looking at spatial configurations of existing plans, I found layouts interesting that had more unconventional circulation patterns. In particular the spaces that were formed through the resulting overlaps or intersections.

I began by looking at the spaces created when horizontal and vertical walls were randomly arranged in a uniform grid. Developing this further I introduced a wider variety of rotations and intersections to see how this would impact the spaces in-between.

In an attempt to escape the rectangular boundary I experimented with sequences of squares and circles in different sized grids, creating spaces from the overlapping boundaries. By merging these varying scaled shapes as if they were layered, I was able to begin to create a more hierarchical spatial pattern.

Additionally, I began looking at how one of these patterns could be placed on a site, and will explore further how aspects of the site could be implemented as parameters for my future code.

## CONTROLLED UNPREDICTABILITY

I was inspired by the ”calculated randomness” of plans like Fujimoto’s Children’s Center for Psychiatric Rehabilitation, where the programmed elements seems to be randomly shuffled.

With set parameters – conditions for form, construction, utility, site and so on – in combination with automatic randomizing many different propositions of such plans could be generated through programming, and maybe result in finding unexpected configurations.

I created a program that could shuffle objects like walls, rooms, pillars by placing them randomly on a predetermined area and assign each a randomized angle (A_001). This generated plans that was totally random, and though I could change the values of angle and plane, the arrangement of the elements was uncontrollable.

From that I tried to add controlling parameters by using predetermined objects like curves to add a level of intention, though still keeping the randomness of angles (A_002 – A_003).

By constraining the random shuffling within smaller areas the outcome could be further controlled.  By using a combination of these two methods (within area and along curve), and experimenting with different types of elements, I could generate outcomes that were generally controlled and still quite unpredictable each time (A_004 – A_007).

I chose the site from the map of future developments of Årsta and Årstafältet. I am intrigued by the crossroads on the field, since I think they can be used as parameters in the system, as one of the constants that can control the randomness.

## Coding dragons

I began looking at codes that were simple in their rule but created a chain of lines and curves. I wanted to break apart an existing code and alter it’s parameters to achieve unique architectural forms. The code I decided to analyse in depth was the ‘Dragon Curve’, which upholds the simple rule:

‘X’ : ‘X+YF+’
‘Y’ : ‘-FX-Y’

Changing the constraints F+-, and the variables XY along with the rule itself has allowed the above geometries to be generated. I am currently in the process of adding to the original code to introduce new spatial characteristics to my findings, and attempting to bring it into the 3D world.

## Forking paths

Here, each plan is a single, continuous forking space generated using a depth-first search algorithm until all cells are visited and all walls are removed in the path of the search – then sorted by wall layout.

The number of cells in the space limits the number of unique alternatives generatable (removing mirrored and rotated duplicates).

2 x 2 cells 1 unique maze
2 x 3 cells 5 unique mazes
2 x 4 cells 12 unique mazes
2 x 5 cells 31 unique mazes

3 x 3 cells 12 unique mazes
3 x 4 cells 112 unique mazes
3 x 5 cells 509 unique mazes
3 x 6 cells 2133 unique mazes

4 x 4 cells 481 unique mazes
4 x 5 cells 5395 unique mazes
4 x 6 cells 20132 unique mazes

5 x 5 cells 9054 unique mazes

Here, two openings are created on side walls, and the size of cell columns and rows are randomly expanded in 1:1 / 2:1 proportions.

## A tool for visualising G-Code

This is an Open Source software (GPL v.3), written in Python, for visualising and manipulating G-code: http://scorchworks.com/Gcoderipper/gcoderipper.html. We have used it to produce this image from the output of Cura (Which is also Open Source, if anyone feels like checking the code), consisting on visualising the tool paths for fuse-deposition 3d printing of a run of Game of Life: