Dwelling the unique constraints and opportunities presented by the .gif format, I had the idea to generate a pattern, and to then use that pattern as a seed for a particle system. As it turned out, this pattern-as-seed plan was pretty convoluted. My pattern held its own aesthetically, and there was no need to abstract it further. At this point, the difficulty was to animate the pattern in a seamless fashion. Golan helped me formulate a solution, which entailed gradually shifting initial velocities according to trigonometric relationships.

I think the .gif succeeds in its playful treatment of stability and instability: the nipples are effectively stationary, where the arm-tentacles twitch and/or undulate erratically. Generally speaking, the experience of the .gif changes dramatically from region-to-region. Maybe this lack of focus is a drawback, and if so, I could improve the piece by unifying it visually. It might also benefit a clarified kinetic gestalt, or put in other words: buttery, logical motion. (Or its charm could lie in the jerky crudeness.)

(As a side note, the edicts of my Nipple Congress have strong ties to those of Jared Tarbell’s Substrate, since a nearly identical branching rule governs the spatial aspect of the forms generated onscreen. )

GridParticle[] gP = new GridParticle[40];
int seed = 10;
PVector texture;

void setup() {
  size(600, 400); 
  randomSeed(seed);
  noiseSeed(seed);
  initGrid();
  smooth();

 background(0,4,118);
}

void initGrid() {
  for (int i= 0; i  < gP.length; i++) {
    gP[i] = new GridParticle(i);
  }
}

void draw() {  
  background(0,4,118);
  randomSeed(seed);
  noiseSeed(seed);
  initGrid();
  for (int n = 0; n < 1400; n++) {
    for (int i= 0; i  < gP.length; i++) {
      gP[i].update();
      gP[i].drawMe();
    }
  }
  filter(INVERT);
  saveFrame();
}

class GridParticle {
  PVector pos; 
  PVector vel = new PVector(0, 1);
  float strokeW;
  int changedThresh;
  int stroke = 235;
  int blinkOffset;

  GridParticle(int _blinkOffset) {
    blinkOffset = _blinkOffset;
    strokeW = 5;
    changedThresh = int(random(0, 10));
    pos = new PVector(random(width*.2, width*.8), random(height*.2, height*.8));
    float randomRadiusX = random(-1,1);
    float randomRadiusY = random(-.5,.5);
    float randomAngle = random(HALF_PI);
    float frameBasedAngle = map(frameCount % 10000, 0, 9999, 0, TWO_PI);
    vel.x = randomRadiusX * cos(randomAngle + frameBasedAngle);
    vel.y = randomRadiusY * sin(randomAngle + frameBasedAngle);
  }

  void update() {

    stroke*=.87;

    float yNoise = map(noise(vel.y/100.0), 0,1, -.002, .002);
    vel.y += yNoise;

    loadPixels();
    if (pixels[floor(width*int((pos.y + 5) % height) + int(pos.x))] != color(0,4,118) || 
       pixels[floor(width*int((pos.y) % height) + (int(pos.x + 5) % width))] != color(0,4,118)) {
      strokeW *= .985;

      vel.x *= -1; 
    }

    pos.x = abs((pos.x + vel.x)) % width;
    pos.y = abs(pos.y + vel.y) % height;
  }

  void drawMe() {
    float vary = noise(pos.x/10.0, pos.y/10.0)*4;
    strokeWeight(strokeW * vary);

    float blink = map((frameCount + blinkOffset) % 10, 0, 9, 0, 1);

    stroke((stroke + 20)*blink, 0, 0);
    point(pos.x, pos.y);
    stroke(0,100);
    point(pos.x-(strokeW * vary),pos.y); point(pos.x+(strokeW * vary),pos.y);
  }
}

My mind process for this project: gif -> looping -> continuity -> time? -> something smooth -> curves? -> water -> flow
In the beginning, in my mind there were two paths for me to take – make something cool-looking/trippy that’s very math oriented, or make something nice to look at/aesthetically appealing. I was a bit lost on the former, so I went with the latter. I wanted something I wouldn’t mind staring at for a few minutes straight, so I ended up with this. I incorporated a lot of random factors so I wouldn’t mind staring at it for a few minutes straight multiple times. I think I invested too much time into trying to make it look pretty when I should have been using that time to try to figure out some cool mathy thing I could incorporate. Oh well, at least I’m happy with the outcome. Enjoyed this project. Will probably want to make another one soon/later.

This was a really quick idea sketch. The lines are really light…

Anyway, here’s the program. There is a lot of randomness involved, so each time you load it, you’re going to get something noticeably different. Enjoy!

 int     nFramesInLoop = 300;
int     nElapsedFrames;
boolean bRecording; 

ArrayList allPaths = new ArrayList();
PImage object;
PImage noncomformity;

//===================================================
void setup() {
  size (300, 150); 
  bRecording = false;
  nElapsedFrames = 0; 
  noFill();

  int which = int(random(3));
  boolean frog = false;
  
  //Randomly choose 1 out of 3 available themes
  //and load image accordingly
  if (which==0) {
    object = loadImage("sakura_flower.png");
  }
  else if (which==1) {
    object = loadImage("maple_leaf.png");
  } 
  else {
    object = loadImage("lily_pad.png");
    int temp = int(random(2));
    if (temp==1) {
      frog = true;
      noncomformity = loadImage("lily_pad_frog.png");
    }
  }

  //Create individual Path objects and append to global ArrayList
  for (int i=0; i<9; i++) {
    Path p = new Path();
    allPaths.add(p);
    //Last object has chance to be a frog
    if (i==8 && frog==true){
      p.changeLook(noncomformity);
    }
  }
}

//===================================================
void keyPressed() {
  bRecording = true;
  nElapsedFrames = 0; 
}

//===================================================
void draw() {
 
  // Compute a percentage (0...1) representing where we are in the loop.
  float percentCompleteFraction = 0; 
  if (bRecording) {
    percentCompleteFraction = (float) nElapsedFrames / (float)nFramesInLoop;
  } else {
    percentCompleteFraction = (float) (frameCount % nFramesInLoop) / (float)nFramesInLoop;
  }
 
  // Render the design, based on that percentage. 
  renderMyDesign (percentCompleteFraction);
 
  // If we're recording the output, save the frame to a file. 
  if (bRecording) {
    saveFrame("output/myname-loop-" + nf(nElapsedFrames,4) + ".png");
    nElapsedFrames++; 
    if (nElapsedFrames > (nFramesInLoop+1)) {
      bRecording = false;
    }
  }
}

void renderMyDesign(float percent) {
  background(255);
  fill(160, 200, 255, 80);
  noStroke();
  rect(0, 0, width, height);

  int n = allPaths.size();

  //Draw background bezier curves first
  noFill();
  for (int i=0; i1) t-=1;
    float thickPercent = sin(2.0*t*TWO_PI);
    float thickness = map(thickPercent,-1,1,thickness1,thickness2);
    stroke(160, 200, 255, 80);
    strokeWeight(thickness);
    bezier(x1, y1, cpx1, cpy1, cpx2, cpy2, x2, y2);
  }

  //Draw moving object
  void drawObject(float percent) {
    //Make sure object is correct size before drawing
    ownLook.resize(int(size)*2, int(size)*2);
    
    //Object starts at random point on curve w/ random rotation
    float t = startT+percent;
    if (t>1) t-=1;
    float x = map(t*width,0,width,x1,x2);
    float y = bezierPoint(y1, cpy1, cpy2, y2, t);

    float cx = x+(size/2);
    float cy = y+(size/2);

    //Draw the object
    pushMatrix();
    translate(cx, cy);
    float angle = (t)*TWO_PI*rotation;
    rotate(angle);
    image(ownLook, -size, -size);    
    popMatrix();
  }
  
  //Change the images of moving object
  void changeLook(PImage change){
    ownLook = change;
  }
}
 

This was an interesting piece for me, as its concept developed further as I felt more comfortable with animating through Processing and programming with Java. As shown in my sketch, I originally intended to create a very simply pattern of movement among lines and dots to keep the work manageable, but as I wrote the code, I started playing for a stronger visual effect. Algorithmic animation always mystified me, but sinking my teeth into the basics gave me a new perspective on this particular art form — both a de-mystification and a new-found respect.

float dx = 20;
float dy = 20;
boolean reverse;

void setup() {
  size(600, 600);
}

void draw() {
  background(0);
  dots();
  if (dx == 91) { //line direction change
    reverse = true;
  }
  if (dx == -11) {
    reverse = false;
  }
  if (reverse) { //animate
    dx--;
    dy--;
  }
  else {
    dx++;
    dy++;
  }
}

void dots() { //draw dots in a matrix
  for (int row = 0; row < 7; row++) {
    for (int col = 0; col < 7; col++) {
      stroke(255);
      strokeWeight(10);
      point(col*100, row*100);
      cardLines(row, col); 
      diagLines(row, col);
      print(row);
    }
  }
}

void cardLines(int row, int col) { //draw lines in cardinal direction
  for (int line = 0; line < 4; line++) {
    pushMatrix();
    cardColor(line);
    translate(col*100, row*100);
    rotate(PI*line/2);
    line(dx, 0, dx+20, 0);
    popMatrix();
  }
}

void diagLines(int row, int col) { //draw lines in diagonals
  for (int line = 0; line < 4; line++) {
    pushMatrix();
    diagColor(line);
    translate(col*100, row*100);
    rotate(PI*line/2);
    line(dx, dy, dx+20, dy+20);
    popMatrix();
  }
}

void cardColor(int line) {
  if (line == 0) {
    stroke(255,0,0,122);
  }
  else if (line == 1) {
    stroke(0,255,0,122);
  }
  else if (line == 2) {
    stroke(255,0,0,123);
  }
  else if (line == 3) {
    stroke(0,255,0,123);
  }
}

void diagColor(int line) {
  if (line == 0) {
    stroke(0,0,255,122);
  }
  else if (line == 1) {
    stroke(255,255,0,122);
  }
  else if (line == 2) {
    stroke(0,0,255,123);
  }
  else if (line == 3) {
    stroke(255,255,0,123);
  }
}