epileptic clock

Here’s the link to the program. I won’t embed it since the already existing embeds are causing unwanted lag on the site… For the most fluid animation, check the clock when your minutes are between 0 and 30. Otherwise there will be wacky framerate on web browsers.

I wanted to make an unstable rippling clock that would bear similarities with uncertain waters. Kind of like a nervous clock that would remind you every time time passes by as we slowly die by the second, minute, hour, etc. Most people check the clock obsessively so here’s to making you even more nervous. Or calmed, I don’t really know what my clock would do to other people; I know I can’t look at the clock for a prolonged period of time. I also have a thing for hidden messages, so I had to put in a mousePressed action somewhere, sorry. And jokey texts at intervals. Maryyann’s GIF project inspired the colors and circular movements, so thanks Mann. I think I achieved the fluidity of time well and succeeded at the transience of the visuals. There are some buggy elements though whenever I ran it, like the visuals always appearing at the origin (which is the reason for the frame), and a lot of lag on web browsers. I believe this lag is due to my inefficient code of using 2D arrays and many for-loops for excessive operations. Maybe I should’ve made a class. Oh well, it runs fine on my computer…

Here’s how the clock works at various time intervals:

noisy cube

squared

I had a previous idea boiling in my head since last week but I just couldn’t figure out a generic algorithm for it to apply to 3 < n < 11 sided regular polygons. I had the code half-written out, and then scrapped it because I felt stifled. Then I had the fantastic notion of working in 3D. It turns out working in 3D in Processing, especially on Windows, is a terrible idea: I kept getting errors that could only be avoided by working on a Mac. I slowly fell into a negative feedback loop of badness and felt bad in general while working on the GIF. Translating things from a drawing to a computational form is difficult and frustrating; so what you see above isn’t what I envisioned, but it’s as close as I can get with my current level of comfortableness with working with graphics in code. I wish I had more time to understand P3D better so that I could add more things to the GIF but ah well.

In short, I wanted to make the cube vibrate even more, and maybe even add more colors to it. Also, the particles were really supposed to be particles; instead they came out looking terribly rectangular, but I don’t really know why.

wow

int grad;
float vibrate = 0.5;
float wiggled = 0.1;
float wiggle;
int particleCount = 1000;
Particle[] particles = new Particle[particleCount+1];
float rx;
float ry;
float t = 0;

void setup()
{
  smooth();
  noFill();
  stroke(255);
  strokeWeight(3);
  smooth();
  size(600, 600, P3D);
  float horiz = 0;
  for (int i = 0; i < particleCount - 4; i+=5) {
    particles[i] = new Particle(width/2, horiz); 
    particles[i+1] = new Particle(width/2+1, horiz);
    particles[i+2] = new Particle(width/2-1, horiz);
    particles[i+3] = new Particle(width/2+1, horiz + 3);
    particles[i+4] = new Particle(width/2-1, horiz + 3);
    horiz+=5;
  }
  for (int j = 0; j < particleCount; j++) {
    particles[j].drawticle();
  }
  rx = 0;
  ry = 0;
  grad = 0;
}

void draw() {
  if (grad > 255) {
    grad = 0;
    background(255);
  }
  else  background(0);
  fill(grad);
  pushMatrix();
  translate(width/2+vibrate, height/2+vibrate);
  rotateX(rx);
  rotateY(ry);
  box(100*wiggle);
  popMatrix();
  for (int k = 0; k < particleCount; k++) {
    particles[k].update();
    particles[k].drawticle();
  }
  rx+=0.01;
  ry+=0.01;
  vibrate*=-1;
  grad+=10;
  wiggle = noise(wiggled);
  wiggled+=0.1;
}

class Particle {
  float xpos;
  float ypos;
  Particle(float x, float y) {
    xpos = x;
    ypos = y;
  }
  void update() {
    if (ypos == 0)
      ypos = 600;
    ypos-=1;
  }
  void drawticle() {
    hint(DISABLE_DEPTH_TEST);
    camera();
    noLights();
    ellipse(xpos, ypos, 0.1, 0.1);
    hint(ENABLE_DEPTH_TEST);
  }
}

MELANIE-LookingOutwards-2

Garden Of Eden // Rule 110 by Peter Curet

This is a case where title greatly affects how I interpret the visuals; I could see the garden, specifically the Garden of Eden, and kept projecting what I know of the story of Garden of Eden onto the visuals. The result is fascinating; these abstract shapes become narrative. It’s obvious in the beginning because the shapes form a garden of sorts, but as time goes on, the shapes become more and more abstract, and I continued to connect the concept of Eden to the shapes. The ending is worth watching, only because there were so many complex generative shapes before and then suddenly, it all gets quiet…

Midimals by Georg Reil

Creation of sound loops is pretty common, but the way Georg Reil used the visual interface to make it seem magical is really cool to me. I’m a sucker for the idea of generating visuals with just my hands, physically touching the materialized sound. It’s also unique to find beautiful visualization of such interface in the first place, and the freedom to create shapes that correspond to the loops is inspiring. I guess I really like technology disguised as magic. I just wish there was a better documentation of it.

unnamed soundsculpture by Daniel Franke and Cedric Kiefer

This was the first thing that popped up after I googled “sound sculpture,” so I presume it’s pretty famous? And rightly so. Although they do not mention it in the process, the documentation video shows that they used Processing, presumably for collecting and manipulating the movement data from Kinect. At first I wasn’t impressed, but as they started introducing dynamic camera angles and blackness, I became mesmerized by how fantastical it looked despite being a digital form. It almost looked like a weeping goddess, if I’m allowed to be that dramatic… I’ve always appreciated dancers and the artful contortions of the human body, but this makes me appreciate the sense of unreality dance can portray through technology. The constant afterimages gave the impression that there were often multiple people dancing together, and the imagery of gravity is powerful by the end of the piece. And it’s beautiful, especially when the dancer stops moving and the particles become static and shadowed. I just have one complaint: I wish it were more dynamic at some points, to keep the audience engaged and tickled. At times it suffers from the trap dance performances fall into: letting their audience go. Though, I wonder if that’s the fault of the dancer and not the algorithm?

public sun, personal sun

sunset

There are two recipes: one uses sunset and the other uses sunrise as trigger. Each event produces different Blink(1) patterns to simulate the color spectrum that happens at sunset or sunrise. The duration of the patterns also tries to match the approximate duration of the phenomena. The sunrise and sunset, however, aren’t in Pittsburgh; they are in one of the most polluted cities in the world, Linfen (China). I imagine this Blink(1) to be in Linfen (or really, any other extremely polluted city that can seldom see the sun, or rather, that can’t see the true colors of the sky when sun sets or rises), shining in the midst of the city for people to see the vibrant colors of the sky when the sun rises and sets. It would be cool to see the Blink(1) attached to a sort of a pole that would enable it to go up and down, matching the sun’s movements over time. I call this the public sun:

publicsun copy

There’s a personal sun too; I imagine the light to be inside a translucent white ball.

personalsun copy

This isn’t an environmental message; it’s for the people living in a gray city to enjoy at least little of their space being illuminated by the actual colors of the sky when the sun sets or rises, rather than the red/yellow that manages to penetrate the thick air. I don’t really expect people to react strongly to it or even catch on to the reason the light is changing within a specific color spectrum at a specific moment, but I do want to brighten up the day for those who do know what the public/personal suns are about.

It would also be a good time indicator too in general for the utilitarians.

(P.S. all the GIFs aren’t really representative of the time span of the suns)

esrever

  1. PERMANENT RULE: lines must never cross each other, but they may touch.
  2. Draw a line of any length and angle.
  3. Draw non-parallel lines of any length and angle branching off the line from #2 (or the perpendicular line, if #3 is reached from #5).
  4. Draw a line perpendicular to one of the lines. This new line should be of smaller length.
  5. You can skip this step, or repeat #3 on that perpendicular line.
  6. Keep drawing perpendicular lines to the previous line* from #4 (if you skipped #5) or #5 until a rectangle is made with a side made from that line*.
  7. Repeat #4 and #3 as much as you want in that rectangle.
  8. Repeat #3-7.
  9. If there are empty spaces you want to fill, repeat #2-7 until satisfied in other areas.

img009 img010(a more diligent person would recurse even more)

my head still hurts

img007

This experience was pretty awful. I’m really bad at following both spoken and written directions and have a difficult time parsing meaning in really long sentences. I actually made a first attempt and failed miserably at it because I couldn’t focus past the third line. So I scrapped it when the third line refused to make even the tiniest bit of sense, and started anew. Maryyann and Ralph gave me some pointers about missing “between”‘s and extra “to”‘s, so that was immensely helpful (those are the ones that gave me the most headaches). I ended up writing sort of a pseudo-code in the text editor Sublime Text, which aided me greatly.

So, this is code, but not the code we’re familiar with. The code we’re familiar with has syntax. It has indentations and logical structure. Sol Lewitt’s instruction does not, yet it is code because the instruction is what happens when style rules are broken at every given point. It is completely unintelligible unless you deconstruct the entire paragraph, or rather, the entire program. That’s the case for humans; for machines, it makes no difference if a line is indented or spaced out for readability. I recall a lesson in a CS class: we write code for humans to read.

I remember now why I don’t write code in a single line even though it’s possible to do so in certain languages: because of the horrors like Sol Lewitt.

beating a dead horse

  1. Talk to the person next to you about anything for 30 seconds. If you can’t find a person, talk to yourself for 30 seconds. The topic can be about anything.
  2. Think of one word to describe what you just talked about.
  3. On paper, draw the word with the word.
  4. Crumple up the paper.
  5. Throw it out a window.
  6. Retrieve the paper. If you are physically unable to retrieve the paper, let it be.
  7. Once you’ve retrieved the paper, open it up.
  8. Trace the wrinkles on the back of the paper.
  9. Once you’re done, crumple it up again and throw it in someone’s face.
  10. Apologize to the person and retrieve the paper.

(the following images are grouped by their front & back)

img001 img002

———-

img003 img004

———–

img005 img006

For this assignment, even though it wasn’t a relevant reading, I found this quote from Art and the API particularly inspiring: “The specific function of modern didactic art has been to show that art does not reside in material entities, but in relations between people and between people and the components of their environment.” I was interested in “instructing” the person what beating a dead horse by repeatedly talking about the same subject would look like. I know I have a tendency to do this a lot, so I thought I would physically manifest this process.

The most hilarious aspect of this was the trouble people had with finding windows, let alone open ones. You’d be surprised at how many closed windows (including insect screen) as opposed to open windows there are around this area–so I expected people to find unorthodox windows. The definition of windows, after all, includes “a thing resembling a window in form or function, in particular.” One person threw the paper out a door, and another person tried to open a window, was confronted with an insect screen, gave up on that step, and moved on.  I was also surprised at what people did with the crumpled paper at the end–two chose not to unfurl it because it wasn’t in the instructions, and one unfurled it by accident (her friend unraveled it).

Mostly, I was interested in how people would interpret “3) On paper, draw the word with the word.” One actually said out loud, “How can I draw this with a pie? I don’t have a pie with me!” which surprised me because it was a miscalculation on my part. I had no idea people would attempt to draw the word with the object the word referred to. But as expected, interpretations varied; the word “pie” was written with many many pies, the word “rubbish” (misspelled as “rubish”) was written with “rubish” all over, and the word “fruit” wasn’t even drawn as a fruit–it was a cup of orange juice, according to the person who drew it. So I think I got this part right for showing interesting variations and thought logic people have when presented with a vague statement like “draw the word with the word.”

I would definitely tinker with using an actual pen (probably a marker) instead of a measly pencil. You could barely see the traced wrinkles on the back. I would also introduce more aspects of repetition; in retrospect, the point of the project wasn’t emphasized well. Repetitions could include talking to multiple people to fill the paper up with more drawn words, or just draw more word associations from that single topic. After all, the resulting drawing itself wasn’t very interesting–it was just the process that was interesting.