Check out this cool animation. You control how colors pulse through three sets of overlapping circles.

Explore.

Move your mouse and click around to see what happens.

Moving your mouse towards the top of the screen for a slow cycle, down to the bottom for a faster cycle. Move to the right for bigger circles and left for smaller ones.

Clicking changes the size and orientation of the circles.

h – toggles rotation of hue
b – toggles rotation of brightness
s – toggles rotation of saturation

p – turns on paint mode. The screen doesn’t refresh between frames
c – chooses a new random color seed

If you make an image you really like, hit the “o” key and you will get a downloadable PNG.

Yet another golden mean animation.

This one is really more golden spiral than golden mean. It starts out as just a regular old logarithmic spiral with the angle of curvature gradually growing until it reaches phi and then passes just slightly through it and back again. I love that moment right when it hits phi and it almost seems to come alive, then lose the life again as it recedes back into just a regular shape. Like it’s breathing.

It’s interactive. Move the mouse to control it.

Moving left and right changes the size of the dots
Moving down increases the angle of spiral, Up decreases it.
B toggles between black and white and color modes
P turns on “paint mode” where the animation leaves trails behind it.
G pulses the dot size
1,2,3,4 control how many spirals are in the animation (2 by default).

// Rotation of items at 137.5 degrees
// Golden Rectangle sized canvass naturally.
float phi=1.6180339;
float  dimX=600,dimY=dimX/phi;
float angle=0;
float lX,lY,nX,nY;
float R,A;  // Constants
int redAmt=int(random(255)),blueAmt=int(random(255)),greenAmt=int(random(255));
color[] phicolors = new color[3];
int cnum=0;
float bigSpin=0;
color gradient1=color(255,000,000,255);
color gradient2=color(000,000,255,255);
float aInc=.01, rInc=5, dInc=.03,angleInc=8;
float diameter=0;
float multiple=.12;  // How large are the dots when we start?
float dotSize=0;
float e=2.71828;
float b=.306349;  // (ln phi)/90
float phiPoint=1/b;  // animation gradient cycle length, point where the radian comes alive
int numSpirals=2;
boolean nearPhi=false;
// Defaults are set here
boolean colorAlternate=true,
        cleared=false,
        paintMode=false,
        dotAnimate=false,
        angleAnimate=true,
        animate=true,
        BW=false,
        md=true,
        mr=false ,
        gradient=true;

void setup(){
  frameRate(20);
  size(int(dimX),int(dimY),JAVA2D);
  //smooth();
  background(255);
  A=2;
  R=dimX;
  lX=R*pow(A*b,radians(angle)) * cos(radians(angle));
  lY=R*pow(A*b,radians(angle)) * sin(radians(angle));
  get3Colors();
}

void drawSpiral() {
    for (int $i=0;$i<numSpirals;$i++){
      if (colorAlternate){
        get3Colors();
      }
      rotate(radians(360/numSpirals));
      angle=0;
      lX=R*pow(A*b,radians(angle)) * cos(radians(angle));
      lY=R*pow(A*b,radians(angle)) * sin(radians(angle));
      while (abs(lX)>4 || abs(lY)>4 && (lX<dimX || lY<dimY)) {
      // if nearPhi go into multicolor mode
        //if (nearPhi){
        //   phicolors[0]=color(200,100,100,100);
        //   phicolors[1]=color(200,100,100,100);
        //   phicolors[2]=color(200,100,100,100);
          //stroke(255,255,255,255*A/b);
        //}
       // else {
          //stroke(255,255,255,255*A/b);
          stroke(red(phicolors[cnum]),green(phicolors[cnum]),blue(phicolors[cnum]),255);
        //}
        fill(phicolors[cnum]);

          cnum++;
          if (cnum>2){
             cnum=0;
          }
      angle+=angleInc;
      nX=R*pow(A*b,radians(angle)) * cos(radians(angle));
      nY=R*pow(A*b,radians(angle)) * sin(radians(angle));
      float dsize=10-(angle/10);

      strokeWeight(1);
      // dots are smaller near the origin larger as they get further away.
      diameter=pow(nX*nX+nY*nY,.5)*multiple;
      ellipse(nX,nY,diameter,diameter);
      lX=nX;
      lY=nY;
   }
  }
}

void draw(){
   //if (random(1)>.95){
   // get3Colors();
  //}
    if (animate) {
     if (dotAnimate){
      multiple+=dInc;
      if (multiple>1 || multiple<0.1){
        dInc*=-1;
      }
     }
     if (angleAnimate){
       get3Colors();
       if (A<1.4){
          if (aInc<0){
            aInc*=-1;
          }
        }
       if (A>(1/b)-.25 && aInc>0){
           nearPhi=true;

       }
       if (A>(1/b)-.25 && aInc<0){
           nearPhi=false;

       }
       if (A>(1/b)-.05){
         aInc*=-1;
        }
        A+=aInc;
     }
      /*
   if (R<1 || R>dimX){
        rInc*=-1;
      }
      R+=rInc;
  */
  //drawSpiral();
  if (!paintMode){
    fill(255,255,255,85);
    stroke(255,255,255,255);
    rect(0,0,dimX,dimY);

  }
  translate(dimX/phi,dimY/2);
  bigSpin+=radians(2);
  if (bigSpin>2*PI){
    bigSpin=0;
    //print("reset");
  }
  rotate(bigSpin);
  drawSpiral();  

}
else {
  translate(dimX/phi,dimY/2);
}
}

void get3Colors(){

  // new seed
  if (BW) {
    redAmt=0;
    greenAmt=redAmt;
    blueAmt=redAmt;
    phicolors[0]=color(redAmt,blueAmt,greenAmt,100);
    phicolors[1]=color(redAmt,blueAmt,greenAmt,100);
    phicolors[2]=color(redAmt,blueAmt,greenAmt,100);
  }
  else {
     // cycle length determines how fast we move from red to blue
     if (gradient) {
       float animDistance=.5/(A/phiPoint);
       //print("animDiatance:"+animDistance+"\n");
       int redDistance=int(red(gradient2)-red(gradient1));
       //print ("redDistance:"+redDistance);
       redAmt=int(red(gradient1)+(redDistance*animDistance));
       //print ("redAmt:"+redAmt);

       int greenDistance=int(green(gradient2)-green(gradient1));

       greenAmt=int(green(gradient1)+(greenDistance*animDistance));

       //print ("greeenAmt:"+greenAmt);
       blueAmt=int(blue(gradient1)+(blue(gradient2)-blue(gradient1))*animDistance);

       //print (" blueAmt:"+blueAmt);
       phicolors[0]=color(redAmt,greenAmt,blueAmt,100);
       phicolors[1]=color(redAmt,greenAmt,blueAmt,100);
       phicolors[2]=color(redAmt,greenAmt,blueAmt,100);
     }
     else {
       redAmt=int(random(255));
       greenAmt=int(random(255));
       blueAmt=int(random(255));
       phicolors[0]=color(redAmt,blueAmt,greenAmt,100);
       phicolors[1]=color(redAmt/phi,blueAmt/phi,greenAmt/phi,100);
       phicolors[2]=color(redAmt*phi,blueAmt*phi,greenAmt*phi,100);
     }
  }
}

void mouseClicked() {
  angleInc=mouseY/20+1;
  print("a"+angleInc+"/n");
}

void mouseMoved(){
  //background(255);
  if (mr) {
    R=mouseX;
  }
  if (md) {
    multiple=mouseX/dimX;
  }
  A=min((mouseY/(dimY/3))+.5,(1/b)-.2);
  angle=0;
 lX=R*pow(A,radians(angle)) * cos(radians(angle));
  lY=R*pow(A,radians(angle)) * sin(radians(angle));
  //print("R:"+R+"A:"+A+"\n");
  if (!animate) {
    background(255);
    cleared=true;
  }
  //background(255);
    //translate(dimX/phi,dimY/2);
  //drawSpiral();
}

void keyPressed() {
  if (key == 'a') {
    // pressing s will take a picture.  Won't work on JS version.
    animate=!animate;
    cleared=false;
    print ("animate");
  }
  if (key == 's') {
    // pressing s will take a picture.  Won't work on JS version.
    print("settings:"+"\n");
    print("A:"+A+"\n");
    print("R:"+R+"\n");
    print("multiple:"+multiple+"\n");
    print("numspirals"+numSpirals+"\n");
    //print:("settings:"+"\n");
    saveFrame("output##.png");
  }
   if (key == '1') {
     numSpirals=1;
  }
   if (key == '2') {
    numSpirals=2;
  }
   if (key == '3') {
   numSpirals=3;
 }
   if (key == '4') {
   numSpirals=4;
  }
  if (key == 'r') { // reset
    background(255);
  }
 if (key == 'c') { // reset
    get3Colors();
  }
 if (key == 'b') { // shift to B&W
    BW=!BW;
  }
   if (key == 'p') { // shift to B&W
    paintMode=!paintMode;
  }
  if (key == 'g') { // Animates Dots
    dotAnimate=!dotAnimate;
  }
  if (key == 'G') { // Animates Dots
    gradient=!gradient;
  }
  if (key == 'n') { // Animates Dots
    angleAnimate=!angleAnimate;
  }
  if (key == 'd') { // Mouse moves diameter instead of Radius
    md=!md;
    mr=!mr;
  }
}

More golden mean obsessed animation work. This time, the pattern is centered on phi and the colors cycle in phi relationship to each other. I also re-worked the interactivity to be based on mouse movement instead of clicking. For interesting images, try moving the mouse in small circles near the top right of the image, or in vertical lines from bottom left to top on the right side.

It’s amazing how fast this runs on Chrome.

Move the mouse around to control it:
Left and Right control dot spacing.
Up and Down control dot size.
“R” – Clears the screen (reset)

I also tried doing some high resolution versions to print out at large-scale (30″+). Click the thumbnails to see the high resolution images.

Here’s the sourcecode:

// Rotation of items at 137.5 degrees
// Golden Rectangle sized canvass naturally.
float phi=1.6180339;
float  dimX=600,dimY=dimX/phi;
float distance=4;   // Spreading of the dots
float ox,newx=dimX/2;
float oy,newy=dimY/2;
float diameter=20;  // Width of the outer dots.
float growth=1;  // Speed of growth
int numSeeds=144  ;   // number of seeds should be a fibonacci number.
float rot=0;
int i;
float direction=-1;
float spinAmt=1;
boolean randomColor=true; // Uses black and white by default.
color mColor=color(255,255,255);
float redAmt,blueAmt,greenAmt=0;
boolean decRed, decBlue, decGreen;
boolean cShift=true;
float countInc=-.5;
color[] phicolors = new color[3];
int cnum=0;

void setup(){
  size(int(dimX),int(dimY),JAVA2D);
  smooth();
  background(255);
  fill (mColor);
  stroke(1,255);
  get3Colors();
  placeSpots();
}

void get3Colors(){
  redAmt=int(random(255));
  greenAmt=int(random(255));
  blueAmt=int(random(255));
  mColor=color(redAmt,blueAmt,greenAmt,155);
  phicolors[0]=color(redAmt,blueAmt,greenAmt,255);
  phicolors[1]=color(redAmt/phi,blueAmt/phi,greenAmt/phi,255);
  phicolors[2]=color(redAmt*phi,blueAmt*phi,greenAmt*phi,255);
}

void placeSpots() {
  translate(dimX*(1/phi),dimY/2);
  rotate(spinAmt);
   for(i=1;i<numSeeds;i++){
    rot+=radians(360/(phi*phi));
    newx=(i*distance*sin( rot));
    newy=(i*distance*cos( rot));
    ellipse(newx,newy,diameter*i*.02,diameter*i*.02);
   }
}

void draw(){
  diameter+=countInc;
  if (diameter==0 || diameter>100) {
    countInc*=-1;
    get3Colors();
  }
  rot=0;
  spinAmt+=137.5*direction;
  fill(phicolors[cnum]);
  cnum++;
      if (cnum>2){
        cnum=0;
      }

  placeSpots();
}

void mouseMoved(){
  distance=float(mouseX)/70+1;
  diameter=float(mouseY)/2+5;
  direction*=-1;
  );

}

void keyPressed() {
  if (key == 'c') {
      // pressing c will toggle color and B&W
    randomColor=!randomColor;
    get3Colors();
  }
  if (key == 's') {
    // pressing s will take a picture.  Won't work on JS version.
    saveFrame();
  }
  if (key == 'r') { // reset
    background(255);
  }

}

A swirling vortex exploring the golden mean, phi and the arrangement of almost all things that grow.

It’s interactive:
Clicking towards the left spaces the dots more closely, to the right, further apart. Click towards the top for smaller dots, towards the bottom for bigger. Each click toggles between expansion and compression. Easter egg: “c” toggles between black and white and a random color.

Here’s the science.

Here’s the sourcecode:

// Rotation of items at 137.5 degrees
// Golden Rectangle sized canvass naturally.
float phi=1.61725;
float  dimX=600,dimY=dimX/phi;
float distance=3;   // Spreading of the dots
float newx=dimX/2;
float newy=dimY/2;
int diameter=50;  // Width of the outer dots.
float growth=1;  // Speed of growth
int numSeeds=144  ;   // number of seeds should be a fibonacci number.
float rot=0;
int i;
float direction=-1;
float spinAmt=1;
boolean randomColor=false; // Uses black and white by default.
color mColor=color(255,255,255); 

void setup(){
  size(int(dimX),int(dimY),JAVA2D);
  smooth();
  fill (mColor);
  stroke(1,255);
  placeSpots();
}

void placeSpots() {
  fill (mColor);
   for(i=1;i<numSeeds;i++){
    rot+=radians(137.5);
    newx=(i*distance*sin( rot));
    newy=(i*distance*cos( rot));
    ellipse(newx,newy,diameter*(i*.01),diameter*(i*.01));
   }
}
void draw(){
  fill(0,0,0,255);
 // rect(0,0,dimX,dimY);
  translate(dimX/2,dimY/2);
  rotate(spinAmt);
  rot=0;
  spinAmt+=radians(137.5)*direction;
  translate(dimX/2,dimY/2);
  placeSpots();
}

int randomSign(){ //returns +1 or -1
  float num = random(1);
  if(num<.5)
    return -1;
  else
    return 1;
}

void mouseMoved(){
  distance=(mouseX/70)+1;
  diameter=mouseY/2+5;

  placeSpots();
  //direction*=-1;
}

void keyPressed() {
  if (key == 'c') {
      // pressing c will toggle color and B&W
    randomColor=!randomColor;
    if (!randomColor){
      mColor=color(255,255,255);
      stroke(100,100,100,150);
    }
    else {
      mColor=color(random(255),random(255),random(255));
      stroke(100,100,100,150);
    }
  }
  if (key == 's') {
    // pressing s will take a picture.  Won't work on JS version.
    saveFrame("output##.png");
  }
}

And a few cool looking images along the way.

I think it’s pretty hypnotic.

It’s interactive: Click to change the animation. Click the left side for skinny tentacles, on the right side for fat ones. Click on the top for short ones and on the bottom for long ones.

This interactive animation is written in processing. I wrote it as a test for the awesome new Processing-JS engine, which converts processing code into HTML5.

If you are visiting in Chrome, Firefox or Safari web browsers, you should be able to see it right below. If you are visiting using internet explorer, I’m really not sure what you see, probably nothing (Let me know). At least you should be able to see some screen captures which give you a sense for the visuals.

Here is the source code for the curious.

Check out the huge heap of awesome that is the mandlebulb or 3d mandlebrot set.  Read the whole story over here at this very strange skytopia project page.   It seems to have been the brainchild and 20 year quest of Rudy Rucker, which he writes about over on his blog, and also over here at fractal forums, where “the elite meet to geek”. There is some math in both places for people who are interested in how this thing was derived.

The quick summary is that this is a mandlebrot set in intersection with both the xy plane and the xz plane.  The math had been around for 20 years but generating fuzzy results which seem to have sharpened up when they changed the exponent from 2 to higher orders.  8 seems to have generated the most impressive results.

I think the images speak for themselves.

Branches rise up and travel on sine wave modified lines. You control the thickness and curviness of the trees.

It’s Interactive: Click to make new trees. Clicking towards the top of the screen makes for straighter branches, towards the bottom for curvy ones. Clicking towards the left makes skinny branches, right makes fat ones.

Requires HTML5 Support (Firefox, Chrome or Safari) to see in the browser. If you are using an unsupported browser, try the java version over at openprocessing.com.

Source Code Below.

// most basic branching test:
// Draw a straight line for a little while
// If chance of branching is exceeded, then add another branch
int i=0;
int totalBranches=10000;
int numTrunks=10;
float  dimX=521,dimY=452;
float branchOdds=.02;
float moveDistance=2;
int trunkWidth=20;
tree[] trees;
int branchesSoFar=-1;
float newBranchSpinAgleMax=PI;
float minAngle=PI*.0015,maxAngle=PI*1.1;

void setup(){
  size(int(dimX),int(dimY));
  trees = new tree[totalBranches];
  background(255,255,255);
  for(i=0;i<numTrunks;i++){
    trees[i] = new tree(random(dimX),dimY,branchOdds,trunkWidth,moveDistance,minAngle,maxAngle,#000000,0);
    branchesSoFar++;
  }
  smooth();

}

void draw(){

    for(i=0;i<branchesSoFar;i++){
     // print(i);
    trees[i].draw();
  }
    fill(255,5);
   // rect(0,0,dimX,dimY);
}
int randomSign(){ //returns +1 or -1
  float num = random(1);
  if(num<.5)
    return -1;
  else
    return 1;
}

void mousePressed(){
  branchesSoFar=0;
  fill(255);
  rect(0,0,dimX,dimY);

  for(i=0;i<numTrunks;i++){
    trees[i] = new tree(random(dimX),dimY,branchOdds,mouseX/20,moveDistance,minAngle*mouseY/50,maxAngle,#000000,0);
    branchesSoFar++;
  }

}

class tree{
  int bWidth;
  float x1,x2,y1,y2=0;
  float bOdds;
  float mDistance;
  color bColor;
  float bSeg;
  int bGeneration;
  float mnAngle,mxAngle;
  float currentAngle=PI;

  tree(float sx, float sy, float branchOdds, int branchWidth, float moveDistance, float minAngle, float maxAngle, color branchColor, int branchGeneration){
    bWidth=branchWidth;
    x1=sx;
    y1=sy;
    y2=y1;
    x2=x1;
    bOdds=branchOdds;
    mDistance=moveDistance;
    bColor=branchColor;
    bSeg=0;
    bGeneration=branchGeneration;
    mnAngle=minAngle;
    mxAngle=random(minAngle) * randomSign();
}

  void draw(){
    if (x1>0 && y1>0){

      strokeWeight(bWidth);
      if (bWidth>=1) {
        // Draw next segment 10 paces up.
        currentAngle+=mxAngle;
        //print ('\n'+currentAngle+" ");
        x2=x2 + sin(currentAngle)*moveDistance;
        y2=y2 + cos(currentAngle)*moveDistance;;
        stroke(bColor);
        line(x1,y1,x2,y2);
        x1=x2;
        y1=y2;
        if (random(1)<bOdds){
          branchesSoFar++;
          //print("added");
          color newColor=color(10*bGeneration,10*bGeneration,10*bGeneration,155);
          int newWidth=int(trunkWidth-bGeneration*2);
          float newAngle=mnAngle*1.35;
          trees[branchesSoFar] = new tree(x2,y2,bOdds,bWidth,moveDistance,newAngle,maxAngle,newColor,bGeneration+1);
        }
        bSeg++;
        if (bSeg/10==int(bSeg/10)){
          bWidth--;
        }
      }
    }
  }
}

Just take a look at these amazing photos that came back from NASA’s Mars Reconnaissance Orbiter which has been orbiting and photographing mars since 2006 at resolutions of an inch a pixel.

ice erosion, south pole of mars

They look so organic to me, so suspiciously similar to the living processes that are at play all around us here on the earth.  It really makes me think about what we mean by the word “organic”. Websters says “of or relating to living organisms”, yet few would argue that these pictures are indications of life on mars.

They sure look like the result of living processes to me though.  They look so much like living things do: composed of cells, shifting through time, gradually settling, and then decaying away. We are all familiar with these kinds of facts as they are the fundamental facts of the earth.  These photos show that they are quite clearly fundamental processes of Mars as well.

I would argue that they are processes of living systems, period. The surprising conclusion being that the wind, the sea and the stones around us are every bit as alive as we are, and possessed of the same patterns that animate our progress and interactions.

How far a leap is it to assume that there is some source at the heart of the universe somewhere in some abstract center that animates it all, pulsing out some string of ons and offs that ultimately becomes everything around us. Like some huge resonating field that snaps otherwise lifeless dust into animated patterns by way of invisible but ever-present energy.

You be the judge:

impact crater, mars

decaying leaf, earth

thermal expansion, mars

plant leaf cells, earth

dust devil trails, mars

tree branch shadows, earth

Some new processing work. click the mouse to change the colors and start new shoots growing. This has a really cool texture if you render it at the high resolution. Here is the source code if anyone is interested.

Here are a few screen grabs from versions that looked cool along the way:

int isBig=1;       // 0 is 500x500 big is 5000x5000
//int dimx = 6000 ;   // width
//int dimy = 6000 ;   // height
//int num = 2000;    // number of hairs
//int startDist = 10;   // minimum distance out
//int endDist =1500;    // maxumum distance out
//int colorChange=300; 

int dimx = 400 ;   // width
int dimy = 400 ;   // height
int num = 500;    // number of hairs
int startDist = 1;   // minimum distance out
int endDist = 75;    // maxumum distance out
int colorChange=60; 

int brushWidth = endDist-startDist;   // differehce between them is the drawing zone.
int startx;
int starty;
float startAngle = random(num)/num * TWO_PI;
float vblueratio=2;
float vgreenratio=2;
int vredBase=0;
int frames=0;
int totFrames=0;
int black=0;

circ[] strands;
color[] colorArray = new color[7];
int currentColor=0;
int colorVariation=30;

void setup() {
// grow lots of stuff if th is is for a big printable output
//FFC600 FF9A00  FF6800 B82900 8C0100 fbc465
  colorArray[0]=#FFC600;
  colorArray[1]=#FF9A00;
  colorArray[2]=#FF6800;
  colorArray[3]=#B82900;
  colorArray[4]=#8C0100;
  colorArray[5]=#fbc465;
  colorArray[6]=#3f0051;
  colorMode(RGB,255);
  //strokeCap(ROUND);

  strands = new circ[num];
  size(dimx,dimy,JAVA2D);
  background(#ffffff);
    // Draw each particle some distance from the origin on a circular path
  int sx,sy;
    startx=dimx/2;
    starty=dimy/2;
  for (int i=0;i<num;i++) {
    //startAngle =sin(PI/360 * i *20);;
    startAngle = random(1)*TWO_PI;
    //startAngle = 0;
    //int rlength = int(random(brushWidth));
    int rlength=int(random(brushWidth));
    startx = 200;
    //print(startx);
    starty =  i;
    //startx = int(dimx/2 + cos(startAngle) * (rlength+startDist));
    //starty = int(dimy/2 + sin(startAngle) * (rlength+startDist));
    strands[i]=new circ (startx,starty,rlength,startAngle,i);
    //strands[i]=new circ (dimx/2,dimy/2,rlength,startAngle,i);
   //print("created: "+i+" length"+rlength);
   //strands[i]=new circ (40,50,60,PI);
  }
}

void draw() {
  for (int i=0;i<num;i++) {
    strands[i].move();
  }
  if (frames==int(colorChange)){
    String fname= String.valueOf(month())+"-"+String.valueOf(day()+"-"+String.valueOf(hour())+"-"+String.valueOf(minute())+"-"+String.valueOf(second()));
        //saveFrame(fname+".png");
  }
  if (frames==colorChange){
    //print ("changing Colors");
    //saveFrame("output##.png");
    //Taking the color array's colors
    //if we are at the end, we go back to the start
    //We add random[colorVariation] to make it interesting.
    currentColor++;
    if (currentColor==colorArray.length-1){
      currentColor=0;
    }
    //print("changed Color to:"+colorArray[currentColor]);
    vredBase=int(random(155)+25);
    vblueratio=random(10);
    //vblueratio=1;
          if(vblueratio==0){
            vblueratio=1;
          }
    vgreenratio=random(7);
    //vgreenratio=1;
    if(vblueratio==0){
            vgreenratio=1;
          }
    //vgreenratio=random(50)+20;
    frames=0;
  }
//  if (totFrames==300){
//    exit();
//  }
//  else{
//    print (totFrames+"\n");
//  }
  frames++;
  totFrames++;
}

void mousePressed() {
  frames=colorChange-1;
  for (int i=0;i<num;i++) {
    strands[i].age=colorChange-1;
  }
  //print (frames);
}

void keyPressed() {
  // pressing a key will take a picture
  //saveFrame("output##.png");
}

Just discovered this incredible java-based open source flash-like product called processing.  Very simple to work with and excellent if you are trying to make art-like output for printing.  Lets you render at very large scale and output to very large images.

Here’s a digital take on the 8th painting in the ox herding series.

It looks different every time. Here are some random renderings that I liked:

<br /> No Java 2 SDK, Standard Edition v 1.4.1 support for APPLET!!<br />

Here is more of a spherical version:

And here is a hi-res image over here, and a little cut-out to give you a sense for the texture: