Making a parametric snowflake with a help of Coch curve algorithm

Tools: Rhinoceros, Grasshopper, Python

Winter is coming … I hope it will snow because snowflakes are awesome. Each of these “tiny miracles of nature” has a unique pattern. To generate this pattern in grasshopper let’s first take a look at the way it is made.

Morphology

Before designing an element of a particular form it is necessary to understand a process that leads to such form. A snowflake is an ice crystal made from water molecules. A molecule H2O has two light hydrogen atoms attached to one heavier oxygen atom. Electric forces between the atoms forces the molecules fit together in hexagons. This interaction is known as hydrogen bonding.

A snowflake starts as a flat hexagon and as new molecules stick to it the lattice grows into a six-pointed crystal. In this crystal structure, there are sixth-order symmetry axes. By the way, these are not simple sixth-order axes, but helical ones, which are a combination of 60 ° rotation with partial translation along the axis. Because of it’s molecule structure a snowflake can have the infinite number of variations, which however all are defined by specific patterns of growth (The Wegener–Bergeron–Findeisen process)

What is important:

• Six-fold radial symmetry. (The number of rays is fixed to six)
• Hexagonal lattice
• Fractal growth.

The idea is to design a pattern on one side of the ray, then mirror it and repeat 5 more times. I will use the Koch Curve as the pattern. Since the fractal growth is defined by recursive algorithm the python component seems unavoidable.

Let’s start with a Koch Curve:

3. Create a mirror copy.

4. Rotate with copies.

5. Enjoy

You might notice that there is no hexagonal grid in geometry. Also it doesn’t really “grow” in terms of size. So there is still plenty of room for improvement…

You will find below the code I used for the python component. It was inspired by Jose Sanchez youtube tutorial: https://www.youtube.com/watch?v=iWfepR9gKDg :

You might need some linear algebra basics (from school) to understand the vectors.

import rhinoscriptsyntax as rs
import Rhino.Geometry as rg

centerpt = pt1

def koch(pt1,pt2):
    """Define the Koch curve vertices between the End points (pt1, pt2)."""
    
    p1 = (pt2 - pt1) * dist1 + pt1
    p2 = (pt2 - pt1) * dist2 + pt1
    p3 = (pt2 - pt1) * dist3 + pt1
    
    v1 = (pt2 - pt1)
    w = rg.Vector3d(-v1.Y, v1.X, 0)
    v = dist4 * w + p2
    
    return [pt1, p1,v,p3, pt2]

def rec(pt1,pt2, gens, lineList):
    """Create a recursion. Connect the points with lines in order."""
    
    if(gens > 0):
        
        newPts = koch(pt1, pt2)
        line = rs.AddPolyline([newPts[0],newPts[1],newPts[2],newPts[3],newPts[4]])
        if(gens == 1):
            lineList.append(line)
            
        rec(newPts[0],newPts[1], gens-1, lineList)
        rec(newPts[1],newPts[2], gens-1, lineList)
        rec(newPts[2],newPts[3], gens-1, lineList)
        rec(newPts[3],newPts[4], gens-1, lineList)
        return lineList
        
allLines = []

a = rec(pt1, pt2, gens, allLines)

"""Create a mirror copy. Put all geometry in a list"""
pt3 = rg.Point3d(pt2.X, pt2.Y, pt2.Z+1)
planePts = [pt1, pt2, pt3]
plane = rs.PlaneFitFromPoints(planePts)
xform = rg.Transform.Mirror(plane)
mir = rs.TransformObjects(allLines, xform, copy=True)

obj = a+mir
raylst = [obj]

"""Make 5 rotate copies. Put it in a list"""
for i in range(5):
    ray = rs.RotateObjects(obj, centerpt, 60, copy=True)
    obj = ray
    raylst.append(ray)


"""Flatten the list"""
snowflake =[]

for row in raylst:
    for elem in row:
        snowflake.append(elem)