# WK1: Necklaces

165

1

6

## Introduction: WK1: Necklaces

I started this project by following the week 1 tutorial. After creating two points, I connected those points to a python script that reads in a series of slider parameter values and uses for loops to procedurally build up a list of points.

These points were then transformed into a list of curves by applying a minimum distance threshold.

The curves were then offset and capped using [OffsetCrv], then transformed into planar surfaces using [Boundary].

The planar surfaces were extruded using [Extr] with a set height, and the final volumetric geometry was boolean union'd together with [SUnion].

## Supplies

Rhino, Grasshopper, Pufferfish

## Step 1: Adjustments to Find the Amulet

I continued making adjustments to the python code to generate patterns and settled on a pattern that reminded me of a necklace.

## Step 2: Fabricating the Amulet

Baking the Grasshopper procedure was straightforward.

Importing to Ultimaker Cura was easy and rewarding to see the gcode toolpath preview.

The amulet is sturdy, satisfying to hold, and will make a fetching necklace.

## Step 3: Enter the Spiral

I was curious about integrating a spiral pattern, so I looked up some processing code examples, and added a pattern that would generate a spiral.

The rx slider controls number of rotations, the mod slider controls spiral size.

```if(j % 6 == 0):
count = i*ry + j;
count *= 0.02;
nx = (pt2.X/2) + (count * mod/10) * math.cos(count);
ny = (pt2.Y/2) + (count * mod/10) * math.sin(count);
pt.append(rs.CreatePoint(nx, ny));
```

## Step 4: Combining Spiral and Lattice

I was curious what the geometry transformation pipeline would spit out if I superimposed patterns, so I combined the spiral pattern with a lattice pattern.

```# Spiral generator
#
if(j % 6 == 0):
count = i*ry + j;
count *= 0.02;
nx = (pt2.X/2) + (count * mod/10) * math.cos(count);
ny = (pt2.Y/2) + (count * mod/10) * math.sin(count);
pt.append(rs.CreatePoint(nx, ny));

# Lattice generator
#
if((i + j/2) % mod == 0 or (i - j/2) % mod == 0):
pt.append(rs.CreatePoint(x-pt2.X, y-pt2.Y, 0.0))
```

The result was satisfying. Because both patterns are dependent on the "mod" input variable, tweaks to this slider result in significant changes to the overall composition.