# 3d Printing Fractals (1)

This blog post goes alongside the video:

So going back a little bit to the fractal slicing blog here I wanted to move to generating 3d printed fractals. The first step is to 3d print a 2d fractal - so we can use the 'escape' level as the height, and it produces a very good 3 dimensional object, even if that is only an alternative representation of the 'colour' of the fractal.

To do this, I generated a point cloud, and the code to do this is relatively trivial - the code to work out if a point is inside or outside the fractal is as follows (where input is a complex number)

```
def frac_one(input, c):
return input * input + c
def calc_iterations(location, c, limit=10, circle=2):
if abs(location) > circle:
return 0
for i in range(limit):
location = frac_one(location, c)
if abs(location)> circle:
break
return(i+1)
```

There are multiple python libraries which will convert a coordinates into an .stl or equivalent and then save this nicely, but you can also just save it as a .xyz file and import it into something like meshlab to then turn into a surface, and an .stl and send it to your printer for slicing. Not perfect because the slicing process does loose resolution - i.e. not as good as generating gcode from the direct points, but still a good progress of 'code generated structures'.

For my first iteration, I used `numpy-stl`

which was relatively straight forwards, but I had to generate the vertices as well as the points. I did this relatively straight forwards because I knew it was going to be a plane with no overhangs, so by offsetting each line by 1/2 a unit, it ended up with a net set of triangles:

```
data = []
limit = 15
divisor = 40
offset = (-75,-50)
size = 100
const = complex(0,0)
for i in range(size):
data.append([])
for j in range(size):
point = complex((i+offset[0])/divisor, (j+offset[1])/divisor)
counter = calc_iterations(const, point, limit=limit)
data[i].append(counter)
```

So this is a big single dimension array of heights, and then the following makes an array of vertices neatly - I could possibly have done this in one loop with the above code, but hindsight is always easy. Note here that I offset every other line slightly. The values are all hard coded as a space of 1, because this is experimental art code, not enterprise stuff.

```
vertices = []
for j in range(size):
for i in range(size):
if j%2==0
coord = [i,j, data[i][j]]
else:
coord = [i+0.5,j, data[i][j]]
vertices.append(coord)
vertices = np.array(vertices)
```

Okay, so now we need to make faces:

```
faces = []
for j in range(size):
for i in range(size-1):
this_point = j*size + i
if j != 0:
if j % 2 == 0:
face = [this_point, this_point+1, this_point-size+1]
else:
face = [this_point, this_point+1, this_point-size]
faces.append(face)
if j != size-1:
if j % 2 == 0:
face = [this_point, this_point+1, this_point+size+1]
else:
face = [this_point, this_point+1, this_point+size]
faces.append(face)
faces=np.array(faces)
```

The +1's are what make it index the mid point of the next line, and finally we can make the object:

```
object = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
for i, f in enumerate(faces):
for j in range(3):
cube.vectors[i][j] = vertices[f[j],:]
object.save('object.stl')
```

The outcome is a combination of a file which could certainly be optimised, but is a flat surface - a little bit of work either to make it a closed mesh either in code, or part of the 3d printing toolchain (e.g. meshlab or fusion 360) is still required to make it a printable object with thickness.

And am I satisfied? No, because the issue here is that this is a 3d representation of a 2d object, and I know I can do better.