I recently found an great article about bezier curves by Mike Kamermans. What made it extra amazing was that all the images were open-sourced, interactive files created with Processing JS. You’re able to follow the mathematics of beziers as well understand how they were executed by reading the code.

His brief about calculating offset curves sparked off this concept of layering. By taking the initial bezier and rotate it about the y axis you get a simple and easily adjustable lathe. Offset curves around a lathe create a beautiful layering effect which add quite a bit of dimension. Using gradient fills instead of solids as subtlety to the shape(s) generated. It’s called Eye primarily because the shapes it was generating once I added the gradient fill looked liked an Eyeball. I think in hindsight, this experiment should be renamed iris and because I have an older flash experiment already named eye.

Update – I’ve renamed it Iris.

This experiment was built in HTML5 using the excellent three.js and dat.gui libraries.

I had a decent understanding of the idea so I set about modifying my base code with 3 distinct parts starting from left to right…

1. The interactive 2d representation of the bezier.
2. The rotate-able 3d version of the lathe.
3. Controls created in dat.gui to modify parameters.

After a few versions I was able to get the bezier code as well as the layering effect working in 2d space. I then started working on the 3d shape, constantly adding and refining more parameters. I Isolated a few parameters which affect the animation of the shape and then spent the rest of the time cleaning and refining. Once the majority of the math was done, I spent time creating different view-able options with lines, particles and eventually fills.

Click the image below to see a progression of work

 
version : 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15

I’ve only tested this in chrome so there’s a very good chance it will not work in other browsers due to the needs of WebGL.

I’ve always made a distinction between client-work and personal-work. Sometimes we make choices which prevents us from using a particular technology or an effect in favor of accommodating for the largest viewing audience. I chose to do it in HTML5 instead of flash not because of any particular argument over which technology is better. I’ve worked in flash for years and there wouldn’t be anything relatively new to learn. 3D in HTML5 and was something new to me and one of the best ways to learn new things is to force-ably throw yourself into a project.

If Murphy’s Law came into effect, I can always revert to a flash solution. As it turned out, browser compatibility issues prevented it from looking correct and the HTML5 version was scrapped for an entirely flash based solution.

Once the project was completed, I didn’t want to loose all that effort I spent on the HTML5 iteration so I slowly reformatted the original code using the latest version of Three.js and dat.gui, a framework that easily allowed you to modify parameters contained within a panel.

On a logistical note, I’m hesitant about naming it as the cooper union mark because of the alterations I’ve made to the original design, like the reintroduction of perspective and the addition of cube geometry. So for now, I’d like to call it a variant. Below are a few more randomly generated variants.

DESIGN SYSTEM

I’ve done a few dynamic logos in the past and have always had a bit of fun making them. So when my friends over at Behavior asked me to help out with creating one for the Cooper Union to coincide with their new site, it was impossible to say no. The logo itself (created by Doyle Partners) was a series of planes that were organized in an isometric-looking view that had so much potential for 3D motion.

The mark centers around an abstracted ‘C’ and ‘U’ intertwined in orthogonal space. We wanted the mark to deconstruct itself to it’s basic form of 2D planes which then form to create a composition. We wanted the composition to be randomly generated so what we needed to do was isolate specific parameters (like rotation and distance) that radically changes its look and feel. To do that we need to create a generative design system.

Once we found the parameters, it took a matter of trial and error to clamp which values looked good. For anything rotation related, we choose angles incremented to 45° while position based parameters are numbers divisible by 20. The Cooper Union mark is actually a variation generated using these parameters. After that, it was just a matter of animating these parameters from one set to another using tweening equations. The last thing we did was extend the animation back to the original mark by adding delays between each tweened parameter. On a side note, I do remember having fun changing the speeds to sync up with the tranformers’s transforming sound.

HTML vs FLASH

I’ve had some minor success with learning canvas recently and thought this would be a great way to dive into Three.js, Mr. doob’s 3D framework. For compatibility’s sake I ditched the WegGLRenderer in favor of the CanvasRenderer so it would work in all modern browsers and devices. For the most part, most of my preliminary tests work and so i moved forward with building it it in HTML.

Preliminary test done in Canvas using Three.js

Design system in Canvas using Three.js and jQueryUI

Everything was going splendidly until I hit a nasty roadblock that completely derailed the use of HTML, layer effects compatibility. It wasn’t supported in IE or Firefox and every hack I tried didn’t work or suffered massive performance issues. Removing the multiple/subtractive effects wasn’t an option because it was integral to the branding so there was no other recourse but to sandbag HTML in favor of Flash’s ubiquity among browsers. If i had to sacrifice anything it would be the user experience on mobile devices (who are already accustomed to it and won’t think much of it) than over half of all modern browsers. The final interactive brand was built with flash 10, using PaperVision3D.

A nice outcome of this was learning about perspective nomenclature. The Cooper Union mark is a non foreshortened, oblique projection with a 45 degree rotation. PaperVision3D nor Three.js had that particular angle configuration so I had to hack it by using an orthogonal camera position and using trial and error. I believe the closest approximation to the brand required squeezing the stage/canvas width a by 15%.

This particular experiment was unusual in that I didn’t really have a clear goal in mind. I was trying to solve a particular geometry problem. One iteration led to another which led to another. The end result was just a cleanup of all the iterations so you can see the inner workings. My fiancee wanted to name it colon but I had to veto an name it something more professional like wormy.

I’m slowly learning more about about html5, and I’m finally at a point where I can express some of these ideas at the same fidelity that I had with flash and processing. The reality is that it wouldn’t be possible without some of the open source frameworks available. For this experiment, I use jquery, jqueryui, seb’s vector class and had help from mr elstob.

Iterations
version 01
version 02
version 03
version 04
version 05
version 06
version 07
version 08
version 09
version 10
version 11
version 12
version 13
version 14
version 15
version 16
version 17

I’ve been drawing circles with code for quite a little while now.
For the most part, I’ve been drawing them using a simple sinusoidal equation which I’ve used a ridiculous amount of times.

for(i=0;i<total;i++){
    var percentage = i/total*Math.PI / 180
    var xPos = Math.cos(percentage) * radius + offsetX;
    var yPos = Math.sin(percentage) * radius + offsetY;
    // do stuff with values
}

You don’t have to fully understand trigonometry (although it does help if you do). Plug in some values that change the parameters and you can easily modify code. However, once I started to create arcs, this proved to cause a whole mess of issues, the biggest when determining when to rotate clockwise vs counterclockwise. From my understanding, the sin/cos functions are smart enough to get a range from 0-360°. Once you go pass that, the values reset back to 0°. You can keep track of it using states but the values keep getting clobbered. It’s like the the tall man, small blanket problem. Covering your head makes your feet cold and covering your feet makes your head cold. I wasn’t smart enough to figure this out so I sat on it for a few months, then a few years, I’ve tried tackling this a few times but I’ve always ended up using a workaround instead.

Cut away to a month back. I was reading a post about drawing arcs and circles without using sine and cosine in the main loop. I believe the purpose was to skip trigonometry which can be processing intensive.

var da = (endPositionInRads - startPositionInRads); // distance angle
var ss = 45; // segmenet spacing
var rs = (Math.abs(da) / (Math.PI * 2) * ss); // real segments
var tm = Math.tan(da / real_segments); // tangent multiplier
var rm = 1 - Math.cos(da / real_segments); //radial multiplier

// first position uses sinusoidal
var xPos = Math.cos(startPositionInRads) * radius + offsetX;
var yPos = Math.sin(startPositionInRads) * radius + offsetY;
var tx; // transitionX
var ty; // transitionY
for (i = 0; i < rs; i++) {
    tx = -(yPos - offsetY);
    ty = xPos - offsetX;
    xPos += tx * tm;
    yPos += ty * tm;
    xPos += (offsetX - xPos) * rm;
    yPos += (offsetY - yPos) * rm;
    // do stuff with values
}

(The code is a little larger but it works)

I didn’t think much of it at first. I’ve actually used it before just for the sake of using it. Going back to the arc problem again, I realized that a simple way to not get the modulus 360° problem was to not use sine and cosines at all. Sure enough it worked and the results of that can be seen below.

(left image uses trig, right image just uses math)

I’ve been completely reliant on using sines and cosines for the pass decade that it actually prevented me from doing what I wanted to do. I think I’m going to revisit a few old experiments that I’ve never published due to code complexity and take a look at it from a different perspective. All the iterations can be found below.

version 01
version 02
version 03
version 04
version 05
version 06
version 07
version 08
version 09
version 10

Nudibranch is an experiment inspired by the motions of a spanish dancer, a type of sea slug commonly found on coral reefs. They oscillate their fins symmetrically as well as rhythmically to travel through open water. This experiment is an abstraction of that motion.

In my previous experiment, I was writing code natively in Processing IDE. I’ve had some luck working with the FDT4 IDE for work related projects so I figured it was about time to plunge into the Eclipse framework. It was definitely a challenge getting everything setup but once it was, working in Eclipse was a breeze.

The first step was to create a simple following motion in 3d space using code I found while browsing through the processing forums. I implemented it to a simple chain script that I converted from 2d to 3d. While the mouse follow was technically working, the range I was receiving leaned towards the extreme causing weird jumps in animation. I instead opted for a simple motion that followed a osculating track.

In the balloon experiment, I was exposing much of the math calculations which overcomplicated the code. In this experiment, I used the toxiclibs libraries which handled much of the complex mathematics and saved me quite a bit of time and headaches along the way. The purple dots represent a scaffold for me to visualize the flapping motion. To quickly go over the construction, I’m building the nudibranch in terms of segments, like slices of a banana. Each slice points towards as well as follows it’s parent. I first parse and store all the points of all the segments and then draw those points later.

The next step was to create a simple oscillating line that protrudes from the center of each segment aka the fins. Using sinusoidal motion that’s offset by the segment id, I’m able to get the motion and cause a ripple effect that travels from the head to the tail of the nudibranch.

I added another scale and offset to each segment to make the flapping of the fins less rigid. I also started playing with the visuals creating line segments for better viewing.

I added the mesh fills soon after and proceeded to fine tune the parameters I created to mimic the look and feel of a nudibranch. I had quite a bit of fun modifying the parameters via the controlP5 sliders so I exposed it to the viewer and added quite a bit more which included motions related to audio, as well as the ability to randomize and animate across all parameters.

This was the basis for the nudibranch video which randomly changed form and shape over time. It may not look like a nudibranch any more but the essence is still there. Feel free to download the latest mac and pc desktop apps to view the ful experience.

yeah it’s built in flash

View it here or if you would like to convert it to a proper html5 logo, you can download the source.

Edit : Yes it’s on purpose, yes it’s ironic and yes I’m being a dick about it.

Written images is an upcoming book comprised of artists creating a series of code generated images. The content of each printed book is a random selection of those images, making each book unique. One of the available ways to submit work was to use processing as a medium. I’ve had some minor success manipulating coordinates in 3d space with my previous flash projects so I assumed it would be easy to do it again in processing.

My idea was to create a randomly generated balloon animals, looking specifically at how the joints are connected from segment to segment. Each segment  has a specific length and a specific rotation which would be nested into the next segment until the dog shape emerges. It seemed simple and straightforward enough until I started rotating each balloon segment in 3d space. I assumed all rotations would be easy to create using only the base x,y,z axis rotations but boy was I wrong. Once I started nesting the segments it became harder and harder to predict where the rotations would end up. There was no easy way to solve this and the deadline was fast approaching so I had to shelf the project until I solve the rotation issue.

Without getting into the details, because frankly I still don’t completely understand them. There are a few ways to do rotations in 3d space. There’s Euler angles, matrix transformations, axis angle rotations and quaternion rotation. After testing every option, quaternion rotation seemed to be the solution. I’m slowly understanding quaternions which I learned from this book and this wikipedia article.

The first thing I did was to randomly distribute a set of points that had no dependency with it’s previous segment. The white lines below represents the segment length and random position.

The violet and green lines represents the start and end 3d tangents of each segment respectively. Getting a 3d tangent aka a cross product is a little tricky only because it requires 2 vectors. I only had 1 so I arbitrarily created another one ( you can barely see it as a small white line extending from each segment corner). After normalizing the cross product and multiplying it by a radius I was able to get the violet and green dots that cap the lines.

Using the quaternion solution above, I was able to get a rotation around the off axis created by the segment line. I distributed the angles in relation to an arbitrary total number of points used to generate a circle and then connecting the front and back points to create a cylinder. I now have enough data to connect the lines using a bezier segment. Each line of a segment is comprised of 2 bezier curves, one from the front and 1 from the back. adjusting where the control points of the bezier are position govern the ‘shape’ of the segment.

This is starting to look good but there was an issue with the segment edges. When I linked a segment, the cross products theoretically should be a mashup of the front and back of two segments. Currently there is no mashing going on so i needed a simple way of averaging of 2 vectors.

My first instinct was to use a SLERP which I will not describe because frankly i couldn’t get it to work. Instead I copped out and used a basic LERP which kind of works well enough to be passable. I think if I started to get serious about creating a balloon shape I’ll probably have to switch over. For now it works well enough. You can see the resulting LERP as the red dotted lines that orbits the joint between two segments.

The next step is to systematize all the arbitrary controls into a unified control panel. ControlP5 made it really easy to add controls to the shape without having to create a radically new interface. PeasyCam made it easy to rotate the balloon in 3d space. I’ll still need an easy way to modify each point manually but currently i’m happy with just using a random spread.

I added a few different views to make it more interesting and a randomizer button that repositions the segments over time. There’s still quite a few more things i’d like to add like audio input and video export but I’m happy with the result so far. Maybe if written images 2 rolls around I can resubmit this to the project.

In the meantime please enjoy the progression of work here.
(Source and local version are also available).

Under my umbrella…ella…ella…hey…hey.

In my previous experiment. I used a series of simple methods that calculates rotations in 3d space. For the most part it worked fine, so long as my rotations were parallel to the x, y and z axis. But once the rotation was along an off axis, the math became terribly complex and I entered a world of hurt trying to get my head around quaternions. Pouring through wikis about SLERPs and cross/dot products, I think I finally reached a point were I’ve learned just enough to come up with this umbrella experiment.

I’ve been having some issues with playing java applets online so I created local versions to play with on a mac or a pc.