These are the iterations of the previously discussed grasshopper definition.  The system on the left has its ratios(see first article) set to change at each iteration starting at .3 moving towards .8 and then returning to .3 at even intervals.  The system on the right is used as a control it is permanently set to .5.

Flocking is the subtle organization of part to part relationships. One of the most common examples of this is obviously flocks of birds, such as the starlings at Otmoor(see video after the break). Flocking in that case consists of a couple elements. The first being clustering of parts, so these parts are forming a spatial relationship of proximity. The next being a correspondence to average heading, each of those starlings not only react to the spatial field of the others, but also to the direction in which they are headed. The final element is a collection of average mass, this is almost a example of part to whole, except for the fact that it is less a reaction and more of a product generated by the first two rules. The starlings as a field of objects generate an emergent condition, the first two elements are a reaction, while the center of mass is something else entirely it is an emergent product generated through the complexity of the system.

A Flock of Starlings at Otmoor

The challenge now is to generate an architecture from these systems and emergent qualities. After the initial analysis, it was important to generate an abstract system that could better explain the nuances of the system at work. The first step was creating an object, a boid, which is short for bird and droid. The first boids were developed by Craig Reynolds, for a quick history lesson visit his website, Craig Reynolds. A boid is the perfect solution for this system as it is the most basic shape that shows direction. As explained in the first analysis, the boids must respond both to the proximity of others and the direction. The second part of the image below demonstrates how this was done, there is a circle drawn around the first boid which is double the width, this creates a proximity on which to work. The second step is to rotate the boid based on two conditions a comparison of the vector of the previous boid and the tangent of the proximity circle. For the first iteration this creates solely a perpendicular relationship, but the more iterations that occur the more the angle will vary. This emulates how as the pieces become more distant from the origin there is less control.

The next image demonstrates object avoidance and the most important part of the system. The new arc is generated similarly to the first circle, except that the portion of circle within the first has been removed in order to maintain object avoidance. This is essential because the next step involves a ratio to find the next boid location. The interesting thing about this is that as you adjust boid location at the origin, the ratios will remain, but the position generated will change. This is what creates the reactive system, each boid is reacting to the others.

The following images explain in depth the system described above. The new location is reacting to a chosen ration and the rotation is once again a comparison of the vector from the previous boid and the tangent of the location on the arc. This system is repeated as needed.

I chose only three generation of boids in order to keep the system manageable, however in theory this system could be deployed ad infinitum. One of the final steps of the individual system was to prepare it for aggregation. It made sense to maintain the language of the system and continue the rules set forth.

Finally the system is aggregated together; and once again each of the individual spheres of influence are reacting to each other. Essentially creating flocks that react to other flocks. One of the most interesting things about this project is that it was accomplished within grasshopper, a plug-in for rhino. Grasshopper is a graphic system for coding within rhino, it however follows a very linear program logic. Referring back to the early analysis it is clear that flocking is anything but linear. Flocking would be more suited to a recursive language where there is some kind of conditional statement, such as:

If(boids are too close)

Then(move boids so they are not close)

Otherwise(do nothing)

This kind of conditional statement would be responsive to individual situations. It would loop continuously asking the question, are the boids too close, and when they are no longer in proximity it terminates itself. Grasshopper, however requires that as you build your system the, piece’s reaction is built in.

This is the first tutorial with hopefully more to come.  You can find it in my tutorial section or follow this link Lineweight Tutorial. The tutorial is focused on the workflow between CAD and Illustrator, with the goal being a successful line drawing. This is how I do all of my line drawings. I prefer for the simple fact that what you see is what you get in illustrator, unlike CAD which requires multiple trials before the proper lineweights are applied.