3 October 2013

Madeleine-LookingOutwards-03

Sound Machines – 2011. Sound Machines was created by The Product, a Berlin-based design studio for Volkswagen. It’s a faux-record player that uses a (light? color?) sensor to read slowly rotating “records” that have been concentrically patterned. The data is thrown into a music software package that then processes it and makes beautiful beats! Cool! I really like the idea of taking old technology and remixing it into something novel, as this does well. They were *almost* there in terms of interactivity, I really love the ability to play new patterns based on where the sensor is rotated, but I feel like they could’ve gone further. I wish they had allowed visitors to generate their own records and attempt to play them, although I understand the fear of having a less musically inclined person attempt to draw their own record and have it sound like crap.

NOISY JELLY – 2012. Noisy Jelly was created by Raphaël Pluvinage and Marianne Cauvard as part of a class project at L’Ensci Les ateliers. Players mix and set their own jellies and then place them on a board to create their own jelly soundboards. Super clever use of capacitive sensors and conductivity to create audio signals, I liked that each addable color had different salt capacities as opposed to having players add salt on their own, clever way to help players *and* the computer differentiate between different instruments. The sounds they use are kind of annoying, but they totally work for jelly.

DJ JACKET – 2013. Another sound interface project! Created by Atif Ateeq, the DJ Jacket is a wearable electronic device that communicates with MAX MSP & Ableton Live to do various audio transformations such as noise additions (air horns, scratching), looping, and cross fading. I <3 wearable electronics, I think this provided an interesting way to remix music. Clothing and style are often very relevant to musical genres (rappers namedrop clothing brands all the time, country singers often talk about wearing work boots). His jacket had so many zippers though, I wish he had used some of them as sensors!

3 October 2013

Swetha- Looking outwards

The Tropism Well by Harvey and John is a mechanism that is meant to replace current drinking fountains in public spaces. The well has a large ‘arm’ that holds a pitcher and extends its arm in order to pour water into a cup some participant is holding. This project was very interesting for me since it mimics what we are trying to achieve with the creature assignment. Through the simple motion of the water running up the valve, the figure seems to dip in a calm almost life-like way. The machine is not being controlled, but the water. I though that was an ingenious way to achieve motion. The project also comes to life with the interactions it has with other people; they treat it almost as if it were an animal. It commands attention and parents are eager to get their children to try it. There are also crowds of people who form around it to watch as it gives water.

The Hanging Garden by Aer Studio is a group of plants with LEDs who let you know when they are thirsty by lighting up the LED. This project, much like the one I mentioned before, gives so much character to something that we generally don’t see as having personalities. We know that plants are alive , however having them literally begin to glow in order to attract your attention for food gives them a certain charm or character that is not present otherwise; it highlights their vulnerability and reasserts the fact that only you, their caretaker can help them grow; it’s both humbling and empowering.

The Firewall by Aaron Sherwood is a project which lets the participants interact with the screen in order to generate interesting ripples or ‘fire’. This project seems like it mimics many others but although that may have been an element of the piece what really stands out is definitely the fact that to interact with it, one must press into the screen; This simple change in the structure of these types of projects inspires the audience to interact with the piece in ways that one would not expect; what brings this piece to life for me is definitely the participation of the audience. This is a good example of how to rework something that may be cliche to something interesting, fun, and new; it proves that there are many ways to slice a cake.

3 October 2013

Trypophobia

trypophobia I have to walk through the radio station to get to campus every day, and there’s a small wooded area with lots of leaves on the ground (as there tends to be in the fall). I noticed that some of these leaves have weird holes in them–probably from small, hungry, bugs, but unsettling nonetheless. These creepy leaves reminded me of this phenomena coined trypophobia, where people find themselves intensely afraid of small, patterned holes such as those in lotus flowers or honeycomb. Small, patterned holes are also a regular natural occurrence, besides lotus flower and honeycomb they can be found in wood, plants, coral, sponges, and more. Clearly the art of generating small, patterned holes was worth investigation.

./wp-content/uploads/sites/2/2013/10/screen02.pdf

I ended up with two variants. The first of which has a lot more variation in size and shape, and completely fills the wooded area. I basically shot particles at a board and if they were too close to an edge or another particle they’d fall off. Not very simulation heavy!

import processing.pdf.*;

int inch = 60;
int margin = inch/2;

ArrayList blobs;

void setup() {
  size(inch*12, inch*12, PDF, "screen05.pdf");
  background(255);
  noFill();
  smooth();

  float rad, x, y, maxr, minr;
  float desiredseperation = 0;
  boolean addBlob = true;
  int points, attempts, maxblob;

  blobs = new ArrayList();

  minr = inch/8;
  maxr = 1.5*inch;
  maxblob = 300;
  attempts = 0;

  while ((blobs.size() != maxblob) && (attempts < 6000)) {     rad = random(minr, maxr - map(blobs.size(), 0, maxblob, 0, maxr-minr+1));     points = int(random(5, 25 - map(blobs.size(), 0, maxblob, 0, 20)));     //x = random(margin+rad, width-(margin+rad));     //y = random(margin+rad, height-(margin+rad));    x = (width/2) + random(0,inch*4)*cos(TWO_PI*random(0,2));    y = (height/2) + random(0,inch*4)*sin(TWO_PI*random(0,2));     addBlob = true;     if (blobs.size() > 0) {
      for (Blob other : blobs) {
        desiredseperation = rad + other.r + (inch/8);
        if (dist(x, y, other.cx, other.cy) < desiredseperation) {
          addBlob = false;
          attempts += 1;
        }
      }
      if (addBlob) {
        blobs.add(new Blob(rad, points, x, y));
        attempts = 0;
      }
    }

    if (blobs.size() == 0) {
       blobs.add(new Blob(rad, points, x, y));
    }
  }

  for (Blob b : blobs) {
    b.display();
  }
  println(blobs.size());
}

void draw() {
  // Exit the program 
  println("Finished.");
  exit();
}

class Blob {
  float r;
  float cx, cy;
  int points;
  float px, py, pr, angle, offset;

  Blob (float inr, int inpoints, float inx, float iny) {
    r = inr; // random(inch/8, inch*2)
    points = inpoints; // random(3, 12)
    cx = inx;
    cy = iny;
  }

  void display() {
    beginShape();
    offset = random(0,1);
    for (int i = 0; i < points; i++) {
      angle = TWO_PI*(i+offset)/points;
      pr = random(.6, 1) * r;
      px = cx + pr*cos(angle);
      py = cy + pr*sin(angle);
      curveVertex(px, py);
      if ((i == 0) || (i == points-1)) {
        curveVertex(px, py);
      }
    }
    endShape(CLOSE);
  }
}

./wp-content/uploads/sites/2/2013/10/frame-0214.pdf

The second one used Golan’s particle class to create a fleet of small holes that then drifted away from each other within a larger circle.

import processing.pdf.*;
boolean record;

int inch = 60;

ArrayList particles;

void setup() {
  size(inch*12, inch*12);
  background(255);
  noFill();
  smooth();

  particles = new ArrayList();

  for (int i = 0; i < 150; i++) {     float rad = random(inch/8, inch/4);     particles.add(new Particle(width/2 + random(-inch, inch), height/2 + random(-inch, inch), rad));   } } void draw() {   if (record) {     // Note that #### will be replaced with the frame number. Fancy!     beginRecord(PDF, "frame-####.pdf");    }      background(255);   float gravityForceX = 0;   float gravityForceY = 0.0;   float mutualRepulsionAmount = inch/16;     for (Particle p : particles) {      for (Particle other : particles) {       float desiredseperation = p.r + other.r + (inch/8);              float dx = p.px - other.px;       float dy = p.py - other.py;       float dh = sqrt(dx*dx + dy*dy);       if (dh > 1.0) {

        float componentInX = dx/dh;
        float componentInY = dy/dh;
        float proportionToDistanceSquared = 1.0/(dh*dh);

        float repulsionForcex = mutualRepulsionAmount * componentInX * proportionToDistanceSquared;
        float repulsionForcey = mutualRepulsionAmount * componentInY * proportionToDistanceSquared;

        p.addForce( repulsionForcex,  repulsionForcey); // add in forces
        other.addForce(-repulsionForcex, -repulsionForcey); // add in forces
      }

      /*if (dist(p.px, p.py, other.px, other.py) < desiredseperation) {

      }*/
    }
  }

  // update the particles
  for (int i=0; i<particles.size(); i++) {
    particles.get(i).bPeriodicBoundaries = false;
    particles.get(i).update(); // update all locations
  }

  for (int i=0; i<particles.size(); i++) {     particles.get(i).addForce(gravityForceX, gravityForceY);   }   for (Particle p : particles) {     p.render();   }      if (record) {     endRecord(); 	record = false;   } } // Use a keypress so thousands of files aren't created void mousePressed() {   record = true; } class Particle {   float r;   float px;   float py;   float vx;   float vy;   float damping;   float mass;   boolean bLimitVelocities = true;   boolean bPeriodicBoundaries = false;   float margin = 2;      float offset, qx, qy, qr, angle;   // stuff   float cx = width / 2;   float cy = height / 2;   float boundr = 300;   // Constructor for the Particle   Particle (float x, float y, float inr) {     r = inr;     px = x;     py = y;     vx = vy = 0;     damping = 0.95;     mass = 1.0;   }   // Add a force in. One step of Euler integration.   void addForce (float fx, float fy) {     float ax = fx / mass;     float ay = fy / mass;     vx += ax;     vy += ay;   }   // Update the position. Another step of Euler integration.   void update() {     vx *= damping;     vy *= damping;     limitVelocities();     handleBoundaries();     px += vx;     py += vy;   }   void limitVelocities() {     if (bLimitVelocities) {       float speed = sqrt(vx*vx + vy*vy);       float maxSpeed = 6.0;       if (speed > maxSpeed) {
        vx *= maxSpeed/speed;
        vy *= maxSpeed/speed;
      }
    }
  }

  void handleBoundaries() {
    if (bPeriodicBoundaries) {
      if (px > width ) px -= width;
      if (px < 0     ) px += width;       if (py > height) py -= height;
      if (py < 0     ) py += height;     }     else {       //super tenuous circular boundaries       if (dist(cx, cy, px+vx, py+vy) > boundr - r) {
        vx *= -1;
        vy *= -1;
      }
    }
  }

  void render() {

    float noiseVal = noise((mouseX)*80, 
                            mouseY*80);

    stroke(0);
    beginShape();
    offset = random(0,1);
    for (int i = 0; i < 10; i++) {
      angle = TWO_PI*(i+offset)/10;
      qr = random(0.75, 1) * r;
      qx = px + qr*cos(angle);
      qy = py + qr*sin(angle);
      curveVertex(qx, qy);
      if ((i == 0) || (i == 10-1)) {
        curveVertex(qx, qy);
      }
    }
    endShape(CLOSE);
  }
}

3 October 2013

Looking Outwards 3

One Hundred and Eight – Nils Völker

One Hundred and Eight by Nils Völker is a 2.4 by 1.8 meter wall-mounted grid of garbage bags. Columns of bags deflate in response to the silhouette of a viewer as detected by a camera – although the grid is able to operate autonomously should it be left alone. Unlike many of the other Arduino-based projects I researched, the technical “gee-whiz” aspect of this work is secondary to a study of material and a reversal of expectations. Völiker breathes just enough life into the bags to give them interest, but not so much as to overpower the sensitivity of the forms. In doing so, he transforms the plastic bag from a symbol of waste to an object of awe. I’m impressed by Völker’s disciplined use of interaction itself (at a bare minimum) as an element in a highly formalist work. A principal struggle for artists working with computation lies in tucking away the engineering of an artwork, but this is something that Völkner does to great success. Also, I don’t think Jim Cambell’s Formula for Computer Art applies here, since the signal and response are so elegantly unified.

Noisy Jelly – Raphaël Pluvinage

Raphaël Pluvinage describes Noisy Jelly as a “game where the player has to cook and shape his own musical material, based on coloured jelly.” Here, as in One Hundred and Eight, inanimate objects personified through a simple interaction. But unlike One Hundred and Eight, the jellies are unresponsive until touched, that is, they don’t do anything on their own. Pluvinage uses an Arduino to detect a hand touching a jelly, I presume by passing a small current through it. He uses Max/MSP for the sound – relying on oscillators whose frequency corresponds in some way to the touches. While I normally find pure tones with no harmonics excruciating to listen to, they work well with the jelly. As I see it, the jelly and crude synthesized sounds refer to failed experiments like the Segway, lending the work a jarring retro-future aesthetic with a hint of irony. I especially enjoy how Pluvinage gives the various jelly shapes unique sonic personalities.

SENSELESS DRAWING BOT #2 – So KANNO + Takahiro YAMAGUCHI

Much like mudlevel’s robo-rainbow, SENSELESS DRAWING BOT #2 by So KANNO and Takahiro YAMAGUCHI makes graffiti so that we don’t have to. It raises interesting questions surrounding the notion of authorship, as well as the problem of responsibility when robots can perform illegal tasks on our behalf. Concretely, the bot consists of high pressure washers equipped with spray cans, mounted on a motorized platform with wheels. An Arduino manages the servos used to release the paint – it is unclear from the documentation whether the robot’s movements are being controlled remotely or internally. Unlike the two other Arduino projects I cited, in which art-objects surprised us by being interactive, SENSELESS DRAWING BOT is poetic because gun-wielding robots aren’t normally thought of as art-machines. The work destabilizes our expectations, and exploits our cynicism to convey the message that robots can be machines of creation in addition to machines of destruction.

3 October 2013

Egg Cell

./wp-content/uploads/sites/2/2013/10/Screen.pdf

Screen

I started thinking about this project with the nature of screens. I thought about old fashioned planetariums I had when I was a child, and how they used screens with holes to project constellations on the ceiling. I wanted to make “personal constellations” with my screen:patterns of holes that generated symbols/ imagery specific to my visual vocabulary. I chose a symbol I use in my work, the egg, as the constellation in this instance.

My simulation plays with the radii of circles. A field of particles is set, then a growth rate force is determined by each particle’s distance to a given point. That force is multiplied by the radius of each circle, plus a little added randomness to the particle’s position, to form a design.I could not figure out how to make a curved boundary, so I set the particles manually. I got several interesting, non-cuttable designs from this, like this:

I wanted my particles to behave organically as well, forming an egg of cells. Essentially, an egg cell. I want to return to the design with spring connected particles to achieve this.

/*Rachel Moeller
Particle System:Amebloid 4th Chakric Connections:
                Blood Vessels
9/28/13
*/
class Particle{
  //Center
  float px;
  float py;
  //Velocity
  float vx;
  float vy;
  //Radius
  float radius;
  
  Particle()
  {
   vx=0;
   vy=0;
  }
  
  Particle(float x, float y,float vxx, float vyy, float r)
  {
   px=x;
   py=y; 
   vx=vxx;
   vy=vyy;
   radius=r;
  }
  
  
  
  void update(float friction)
  {
    //friction
    vx*=friction;
    vy*=friction;
    //containment to the window+border
    //condiseration given to maximum radius
    if(px>width-10){vx=-vx;}
    if(px<10){vx=-vx;}
    if(py>height-10){vy=-vy;}
    if(py<10){vy=-vy;}
    //movement
    
    px+=vx;
    py+=vy;
  }
  
 
  
  void render(float gr)
  {
    noFill();
    
    ellipse(px,py,radius*gr,radius*gr);
 
  
  }   
}

Particle[] pArray;
int numParticles;
float emitterX;
float emitterY;
float growthRate;
float originX;
float originY;


void setup()
{
  size(400,400);
  originX=width/2;
  originY=height/2;
  emitterX=(width/2)+50;
  emitterY=(width/2)+50;
  numParticles=260;
  pArray=new Particle[numParticles];
  int j=10;
  int r=2;
  float w2=width/2;
  float a=random(-3,3);
  float ax=random(-3,3);
  float ay=random(-2,2);
 
  pArray[0]=new Particle(w2-5,10,0,0,r);
  pArray[1]=new Particle(w2+5,10,0,0,r);
  //1
  pArray[2]=new Particle(w2-15,25,0,0,r);
  pArray[3]=new Particle(w2,25,0,0,r);
  pArray[4]=new Particle(w2+15,25,0,0,r);
  //2
  pArray[5]=new Particle(w2-35,40,0,0,r);
  pArray[6]=new Particle(w2-20,40,0,0,r);
  pArray[7]=new Particle(w2-7,40,0,0,r);
  pArray[8]=new Particle(w2,40,0,0,r);
  pArray[8]=new Particle(w2+7,40,0,0,r);
  pArray[9]=new Particle(w2+20,40,0,0,r);
  pArray[10]=new Particle(w2+35,40,0,0,r);
  //3
  pArray[11]=new Particle(w2-45,55,0,0,r);
  pArray[12]=new Particle(w2-30,55,0,0,r);
  pArray[13]=new Particle(w2-15,55,0,0,r);
  pArray[14]=new Particle(w2,55,0,0,r);
  pArray[15]=new Particle(w2+15,55,0,0,r);
  pArray[16]=new Particle(w2+30,55,0,0,r);
  pArray[17]=new Particle(w2+45,55,0,0,r);
  //4
  pArray[18]=new Particle(w2-55,70,0,0,r);
  pArray[19]=new Particle(w2-40,70,0,0,r);
  pArray[20]=new Particle(w2-25,70,0,0,r);
  pArray[21]=new Particle(w2-10,70,0,0,r);
  pArray[22]=new Particle(w2+10,70,0,0,r);
  pArray[23]=new Particle(w2+25,70,0,0,r);
  pArray[24]=new Particle(w2+40,70,0,0,r);
  pArray[25]=new Particle(w2+55,70,0,0,r);
  //5
  pArray[26]=new Particle(w2-65,85,0,0,r);
  pArray[27]=new Particle(w2-50,85,0,0,r);
  pArray[28]=new Particle(w2-35,85,0,0,r);
  pArray[29]=new Particle(w2-20,85,0,0,r);
  pArray[30]=new Particle(w2-7,85,0,0,r);
  pArray[31]=new Particle(w2+7,85,0,0,r);
  pArray[32]=new Particle(w2+20,85,0,0,r);
  pArray[33]=new Particle(w2+35,85,0,0,r);
  pArray[34]=new Particle(w2+50,85,0,0,r);
  pArray[35]=new Particle(w2+65,85,0,0,r);
  //6
  pArray[36]=new Particle(w2-75,100,0,0,r*3);
  pArray[37]=new Particle(w2-60,100,0,0,r);
  pArray[38]=new Particle(w2-45,100,0,0,r);
  pArray[39]=new Particle(w2-30,100,0,0,r);
  pArray[40]=new Particle(w2-15,100,0,0,r);
  pArray[41]=new Particle(w2,100,0,0,r);
  pArray[42]=new Particle(w2+15,100,0,0,r);
  pArray[43]=new Particle(w2+30,100,0,0,r);
  pArray[44]=new Particle(w2+45,100,0,0,r);
  pArray[45]=new Particle(w2+60,100,0,0,r);
  pArray[46]=new Particle(w2+75,100,0,0,r*3);
  //7
  pArray[47]=new Particle(w2-85,115,0,0,r*1.4);
  pArray[48]=new Particle(w2-70,115,0,0,r*7);
  pArray[49]=new Particle(w2-55,115,0,0,r);
  pArray[50]=new Particle(w2-40,115,0,0,r);
  pArray[51]=new Particle(w2-25,115,0,0,r);
  pArray[52]=new Particle(w2-10,115,0,0,r);
  pArray[53]=new Particle(w2+10,115,0,0,r);
  pArray[54]=new Particle(w2+25,115,0,0,r);
  pArray[55]=new Particle(w2+40,115,0,0,r);
  pArray[56]=new Particle(w2+55,115,0,0,r);
  pArray[57]=new Particle(w2+70,115,0,0,r*7);
  pArray[58]=new Particle(w2+85,115,0,0,r*1.4);
  //8
  pArray[59]=new Particle(w2-90,130,0,0,r);
  pArray[60]=new Particle(w2-75,130,0,0,r*4);
  pArray[61]=new Particle(w2-60,130+a,0,0,r*5);
  pArray[62]=new Particle(w2-45,130+a,0,0,r);
  pArray[63]=new Particle(w2-30,130+a,0,0,r);
  pArray[64]=new Particle(w2-15,130+a,0,0,r);
  pArray[65]=new Particle(w2,130+a,0,0,r);
  pArray[66]=new Particle(w2+15,130+a,0,0,r);
  pArray[65]=new Particle(w2+30,130+a*3,0,0,r);
  pArray[67]=new Particle(w2+45,130+a,0,0,r);
  pArray[68]=new Particle(w2+60,130+a,0,0,r*5);
  pArray[69]=new Particle(w2+75,130+a,0,0,r*4);
  pArray[70]=new Particle(w2+90,130+a,0,0,r);
  pArray[71]=new Particle(w2,130+a,0,0,r);
  //9
  pArray[72]=new Particle(w2-95,145,0,0,r*2);
  pArray[73]=new Particle(w2-80,145,0,0,r);
  pArray[74]=new Particle(w2-65,145,0,0,r);
  pArray[75]=new Particle(w2-50,145,0,0,r*4);
  pArray[76]=new Particle(w2-35,145,0,0,r);
  pArray[77]=new Particle(w2-20,145,0,0,r);
  pArray[78]=new Particle(w2-7,145,0,0,r);
  pArray[79]=new Particle(w2+7,145,0,0,r);
  pArray[80]=new Particle(w2+20,145,0,0,r);
  pArray[81]=new Particle(w2+35,145,0,0,r);
  pArray[82]=new Particle(w2+50,145,0,0,r*4);
  pArray[83]=new Particle(w2+65,145,0,0,r);
  pArray[84]=new Particle(w2+80,145,0,0,r);
  pArray[85]=new Particle(w2+95,145,0,0,r*2);
  //10
  pArray[86]=new Particle(w2-100,160,0,0,r*2);
  pArray[87]=new Particle(w2-85,160,0,0,r);
  pArray[88]=new Particle(w2-70,160,0,0,r);
  pArray[89]=new Particle(w2-55,160,0,0,r);
  pArray[90]=new Particle(w2-40,160,0,0,r);
  pArray[91]=new Particle(w2-25,160,0,0,r*4);
  pArray[92]=new Particle(w2-10,160,0,0,r);
  pArray[93]=new Particle(w2+10,160,0,0,r);
  pArray[94]=new Particle(w2+25,160,0,0,r*4);
  pArray[95]=new Particle(w2+40,160,0,0,r);
  pArray[96]=new Particle(w2+55,160,0,0,r);
  pArray[97]=new Particle(w2+70,160,0,0,r);
  pArray[98]=new Particle(w2+85,160,0,0,r);
  pArray[99]=new Particle(w2+100,160,0,0,r*2);
  //11
  pArray[100]=new Particle(w2-105,175+a,0,0,r*4);
  pArray[101]=new Particle(w2-90+a,175,0,0,r*2.1);
  pArray[102]=new Particle(w2-75,175+a,0,0,r*2);
  pArray[103]=new Particle(w2-60+a,175,0,0,r);
  pArray[104]=new Particle(w2-45,175,0,0,r);
  pArray[105]=new Particle(w2-30,175,0,0,r*4);
  pArray[106]=new Particle(w2-15,175,0,0,r*5);
  pArray[107]=new Particle(w2,175,0,0,r*7);
  pArray[108]=new Particle(w2,175,0,0,r*5);
  pArray[109]=new Particle(w2+15,175,0,0,r*5);
  pArray[110]=new Particle(w2+30,175,0,0,r*4);
  pArray[111]=new Particle(w2+45,175,0,0,r);
  pArray[112]=new Particle(w2+60,175,0,0,r);
  pArray[113]=new Particle(w2+75,175,0,0,r*2);
  pArray[114]=new Particle(w2+90,175,0,0,r*2.1);
  pArray[115]=new Particle(w2+105,175,0,0,r*4);
  //12
  pArray[116]=new Particle(w2-110,190,0,0,r*1.7);
  pArray[117]=new Particle(w2-95,190,0,0,r*3);
  pArray[118]=new Particle(w2-80,190,0,0,r);
  pArray[119]=new Particle(w2-65,190,0,0,r);
  pArray[120]=new Particle(w2-40,190,0,0,r);
  pArray[121]=new Particle(w2-25,190,0,0,r*1.5);
  pArray[122]=new Particle(w2-10,190,0,0,r*3.5);
  pArray[123]=new Particle(w2+10,190,0,0,r*3.5);
  pArray[124]=new Particle(w2+25,190,0,0,r*1.5);
  pArray[125]=new Particle(w2+40,190,0,0,r);
  pArray[126]=new Particle(w2+65,190,0,0,r);
  pArray[127]=new Particle(w2+80,190,0,0,r);
  pArray[128]=new Particle(w2+95,190,0,0,r*3);
  pArray[129]=new Particle(w2+110,190,0,0,r*1.7);
  //13
  pArray[130]=new Particle(w2-115,205,0,0,r);
  pArray[131]=new Particle(w2-100,205,0,0,r);
  pArray[132]=new Particle(w2-85,205,0,0,r);
  pArray[133]=new Particle(w2-70,205,0,0,r);
  pArray[134]=new Particle(w2-55,205,0,0,r);
  pArray[135]=new Particle(w2-40,205,0,0,r);
  pArray[136]=new Particle(w2-25,205,0,0,r);
  pArray[137]=new Particle(w2-10,205,0,0,r*2);
  pArray[138]=new Particle(w2+10,205,0,0,r*2);
  pArray[139]=new Particle(w2+25,205,0,0,r);
  pArray[140]=new Particle(w2+40,205,0,0,r);
  pArray[141]=new Particle(w2+55,205,0,0,r);
  pArray[142]=new Particle(w2+70,205,0,0,r);
  pArray[143]=new Particle(w2+85,205,0,0,r);
  pArray[144]=new Particle(w2+100,205,0,0,r);
  pArray[145]=new Particle(w2+115,205,0,0,r);
  //14
  //BOTTOM
  pArray[146]=new Particle(w2-115,220,0,0,r*1.5);
  pArray[147]=new Particle(w2-95,220,0,0,r*1.5);
  pArray[148]=new Particle(w2-80,220,0,0,r*1.5);
  pArray[149]=new Particle(w2-65,220,0,0,r*1.5);
  pArray[150]=new Particle(w2-40,220,0,0,r*1.5);
  pArray[151]=new Particle(w2-25,220,0,0,r*1.5);
  pArray[152]=new Particle(w2-10,220,0,0,r*1.5);
  pArray[153]=new Particle(w2+10,220,0,0,r*1.5);
  pArray[154]=new Particle(w2+25,220,0,0,r*1.5);
  pArray[155]=new Particle(w2+40,220,0,0,r*1.5);
  pArray[156]=new Particle(w2+65,220,0,0,r*1.5);
  pArray[157]=new Particle(w2+80,220,0,0,r*1.5);
  pArray[158]=new Particle(w2+95,220,0,0,r*1.5);
  pArray[159]=new Particle(w2+115,220,0,0,r*1.5);
  //15
  pArray[160]=new Particle(w2-110,235,0,0,r*1.5);
  pArray[161]=new Particle(w2-90,235,0,0,r*1.5);
  pArray[162]=new Particle(w2-75,235,0,0,r*1.5);
  pArray[163]=new Particle(w2-60,235,0,0,r*1.5);
  pArray[164]=new Particle(w2-45,235,0,0,r*1.5);
  pArray[165]=new Particle(w2-30,235,0,0,r*1.5);
  pArray[166]=new Particle(w2-15,235,0,0,r*1.5);
  pArray[167]=new Particle(w2,235,0,0,r*1.5);
  pArray[168]=new Particle(w2,235,0,0,r*1.5);
  pArray[169]=new Particle(w2+15,235,0,0,r*1.5);
  pArray[170]=new Particle(w2+30,235,0,0,r*1.5);
  pArray[171]=new Particle(w2+45,235,0,0,r*1.5);
  pArray[172]=new Particle(w2+60,235,0,0,r*1.5);
  pArray[173]=new Particle(w2+75,235,0,0,r*1.5);
  pArray[174]=new Particle(w2+90,235,0,0,r*1.5);
  pArray[175]=new Particle(w2+110,235,0,0,r*1.5);
  // 16
  pArray[176]=new Particle(w2-100,250,0,0,r*1.6);
  pArray[177]=new Particle(w2-85,250,0,0,r*1.6);
  pArray[178]=new Particle(w2-70,250,0,0,r*1.6);
  pArray[179]=new Particle(w2-55,250,0,0,r*1.6);
  pArray[180]=new Particle(w2-40,250,0,0,r*1.6);
  pArray[181]=new Particle(w2-25,250,0,0,r*1.6);
  pArray[182]=new Particle(w2-10,250,0,0,r*1.6);
  pArray[183]=new Particle(w2+10,250,0,0,r*1.6);
  pArray[184]=new Particle(w2+25,250,0,0,r*1.6);
  pArray[185]=new Particle(w2+40,250,0,0,r*1.6);
  pArray[186]=new Particle(w2+55,250,0,0,r*1.6);
  pArray[187]=new Particle(w2+70,250,0,0,r*1.6);
  pArray[188]=new Particle(w2+85,250,0,0,r*1.6);
  pArray[189]=new Particle(w2+100,250,0,0,r*1.6);
  //17
  pArray[190]=new Particle(w2-95,265,0,0,r*2);
  pArray[191]=new Particle(w2-80,265,0,0,r*2);
  pArray[192]=new Particle(w2-65,265,0,0,r*2);
  pArray[193]=new Particle(w2-50,265,0,0,r*2);
  pArray[194]=new Particle(w2-35,265,0,0,r*2);
  pArray[195]=new Particle(w2-20,265,0,0,r*2);
  pArray[196]=new Particle(w2-7,265,0,0,r*2);
  pArray[197]=new Particle(w2+7,265,0,0,r*2);
  pArray[198]=new Particle(w2+20,265,0,0,r*2);
  pArray[199]=new Particle(w2+35,265,0,0,r*2);
  pArray[200]=new Particle(w2+50,265,0,0,r*2);
  pArray[201]=new Particle(w2+65,265,0,0,r*2);
  pArray[202]=new Particle(w2+80,265,0,0,r*2);
  pArray[203]=new Particle(w2+95,265,0,0,r*2);
  //18
  pArray[204]=new Particle(w2-90,280,0,0,r*2);
  pArray[205]=new Particle(w2-75,280,0,0,r*2);
  pArray[206]=new Particle(w2-60,280,0,0,r*2);
  pArray[207]=new Particle(w2-45,280,0,0,r*2);
  pArray[208]=new Particle(w2-30,280,0,0,r*2);
  pArray[209]=new Particle(w2-15,280,0,0,r*2);
  pArray[210]=new Particle(w2,280,0,0,r*2);
  pArray[211]=new Particle(w2+15,280,0,0,r*2);
  pArray[212]=new Particle(w2+30,280,0,0,r*2);
  pArray[213]=new Particle(w2+45,280,0,0,r*2);
  pArray[214]=new Particle(w2+60,280,0,0,r*2);
  pArray[215]=new Particle(w2+75,280,0,0,r*2);
  pArray[216]=new Particle(w2+90,280,0,0,r*2);
  pArray[217]=new Particle(w2,280,0,0,r*2);
  //19
  pArray[218]=new Particle(w2-85+a,295,0,0,r*1.4);
  pArray[219]=new Particle(w2-70+a,295,0,0,r*1.4);
  pArray[220]=new Particle(w2-55+a,295,0,0,r*1.4);
  pArray[221]=new Particle(w2-40,295,0,0,r*1.4);
  pArray[222]=new Particle(w2-25,295+a,0,0,r*1.4);
  pArray[223]=new Particle(w2-10,295+a,0,0,r*1.4);
  pArray[224]=new Particle(w2+10+a,295,0,0,r*1.4);
  pArray[225]=new Particle(w2+25,295,0,0,r*1.4);
  pArray[226]=new Particle(w2+40,295,0,0,r*1.4);
  pArray[227]=new Particle(w2+55,295,0,0,r*1.4);
  pArray[228]=new Particle(w2+70,295,0,0,r*1.4);
  pArray[229]=new Particle(w2+85,295,0,0,r*1.4);
  //20
  //pArray[230]=new Particle(w2-75,310,0,0,10);
  pArray[230]=new Particle(w2-60,310,0,0,r*1.3);
  pArray[231]=new Particle(w2-45,310,0,0,r*1.3);
  pArray[232]=new Particle(w2-30,310,0,0,r*1.3);
  pArray[233]=new Particle(w2-15,310,0,0,r*1.3);
  pArray[234]=new Particle(w2,310,0,0,r*1.3);
  pArray[235]=new Particle(w2+15,310,0,0,r*1.3);
  pArray[236]=new Particle(w2+30,310,0,0,r*1.3);
  pArray[237]=new Particle(w2+45,310,0,0,r*1.3);
  pArray[238]=new Particle(w2+60,310,0,0,r*1.3);
  //21
  pArray[239]=new Particle(w2-55,325+a,0,0,r*1.4);
  pArray[240]=new Particle(w2-35+a,325,0,0,r*1.4);
  pArray[241]=new Particle(w2-20,325,0,0,r*1.4);
  pArray[242]=new Particle(w2-7+a,325+a,0,0,r*1.4);
  pArray[243]=new Particle(w2+7,325+a,0,0,r*1.4);
  pArray[244]=new Particle(w2+20,325,0,0,r*1.4);
  pArray[245]=new Particle(w2+35+a,325,0,0,r*1.4);
  pArray[246]=new Particle(w2+55+a,325,0,0,r*1.4);
  //22
  pArray[247]=new Particle(w2-35,340,0,0,r*1.4);
  pArray[248]=new Particle(w2-15,340,0,0,r*1.4);
  pArray[249]=new Particle(w2,340,0,0,r*1.4);
  pArray[250]=new Particle(w2+15,340,0,0,r*1.4);
  pArray[251]=new Particle(w2+35,340,0,0,r*1.4);
  //23
  pArray[252]=new Particle(w2-20,355,0,0,r*1.5);
  pArray[253]=new Particle(w2-7,355,0,0,r*1.5);
  pArray[254]=new Particle(w2+7,355,0,0,r*1.5);
  pArray[255]=new Particle(w2+20,355,0,0,r*1.5);
  //24+
  pArray[256]=new Particle(w2-72,310,0,0,r);
  pArray[257]=new Particle(w2+3,200,0,0,r);
  pArray[258]=new Particle(w2-2,210,0,0,r*1.5);
  pArray[259]=new Particle(w2+72,310,0,0,r*1.5);
}
    



void draw()
{
   
  background(255);
  for(int i=2;i

3 October 2013

Laser Cut Pattern/ Design- swetha

./wp-content/uploads/sites/2/2013/10/final-1.pdf

UPDATE: I changed the design so that it took out all the white lines, hopefully there is nothing else wrong with it! Thanks Golan!

Ever since the generative art assignment I had been itching to delve into art that took design elements from Indian culture. At the beginning, I was keen on using henna patterns and designs in my laser cut print, however after researching I realized that I did not know much about the art and also was as driven to piece together a code for it. Through my research, I soon turned to Indian architecture. I’ve been to many Indian palaces and all of them seemed to have a few design elements in common, namely the repetition of curves, hexagons, and squares. Particularly, I was looking at the architecture used in various Bollywood movies since they have drastically simplified traditional architecture so that it is much more comprehensive.

Some of the architecture I used and things that inspired me appear in this song, if anyone’s interested:

https://www.youtube.com/watch?v=YxINX5Y6Fr0

I couldn’t sketch my design too well, but I definitely used my sketchbook to work out the placements in the design:

My design is a pattern created using lines and incorporates the design elements I researched. The pattern is also manipulable by moving your cursor along the screen to activate the particles. These particles do not have a gravity force on them but instead have a very simple attraction and repulsion force in them. For each 50 by 50 square of the screen, two cube particles exist in it. These particles will not leave the 50 by 50 square but will instead form designs in the square since one will move toward you and one away. The squares also have friction, velocity, and mass thus making them able to bounce on the walls for a short period of time before coming to a pause. if the image ends up moving into something the user likes, then the user can click to freeze the image and then export from there. I don’t know too much about the laser cutter, but hopefully this design will work.

here’s a few pics of my design to show the variability:


 
  fill(255);
  strokeWeight(0);
  stroke(255);
  rect(44,44,width-88,height-88);
  stroke(0);
  noFill();
  
 for(int row = 0; row< numBallsX; row+=1){
    for(int col = 0; col< numBallsY; col +=1){
      strokeWeight(1);
      
      pushMatrix();
      translate(50+row*50, 50+col*50); 
      if (mouseClicked == false) {   
        balls[row][col].move(0);
        oppositeBalls[row][col].move(1);
      }
      balls[row][col].display(); 
      oppositeBalls[row][col].display(); 
      popMatrix();
      
      pushMatrix();
      translate(50+row*50, 50+col*50);
      createDesign();
      popMatrix();
    }
  }
  
  if(record){
    endRecord();
      record = false;
  }
  
}



void createDesign(){
  strokeWeight(1);
  Hex();
  accents();
  halfHex();
  angles();
  makeBezier();
  
}

void createSquare(){
  smallDesign();
  line(0,7, 7,7);
  line(7,7,7,0);
  line(43, 7, 50, 7);
  line(43,0, 43, 7);
  line(50, 43, 43, 43);
  line(43,50, 43,43);
  line(0, 43, 7, 43);
  line(7,50, 7,43);
}
 void createSmallHex(float a,float b, 
                   float c, float d,
                   float x , float  y,
                   float w, float z,
                   float e, float f,
                   float s, float t){
  line(a, b, c , d);
  line(c, d, x, y);
  line(x, y, w , z);
  line(w, z, e, f);
  line(e, f, s, t);
  }

void smallDesign(){
  createSmallHex(18, 50, 18, 46.5, 21.5, 43, 28.5, 43, 32, 46.5, 32, 50);
  createSmallHex(0, 18, 3.5, 18, 7, 21.5, 7, 28.5, 3.5, 32, 0, 32);
  createSmallHex(50, 18, 46.5, 18, 43, 21.5, 43, 28.5, 46.5, 32, 50, 32);
  createSmallHex(18, 0, 18, 3.5, 21.5, 7, 28.5, 7, 32, 3.5, 32, 0);
  createSmallHex(25, 32, 21.5, 32,  18, 28.5, 18, 21.5, 21.5, 18, 25, 18);
  createSmallHex(25, 32, 28.5, 32,  32, 28.5, 32, 21.5, 28.5, 18, 25, 18);
  
  
  createSmallHex(12, 19, 7, 14, 12, 14, 12, 9, 17, 14, 12, 19);
  createSmallHex(50-12, 19, 50-7, 14, 50-12, 14, 50-12, 9, 50-17, 14, 50-12, 19);
  createSmallHex(12, 50-19, 7, 50-14, 12, 50-14, 12, 50-9, 17, 50-14, 12, 50-19);
  createSmallHex(50-12, 50-19, 50-7, 50-14, 50-12, 50-14, 50-12, 50-9, 50-17, 50-14, 50-12, 50-19);
}

void makeBezier(){
  noFill();
  bezier(40,40,42,40,49,43,44,49);
  bezier(40,40,40,42,43,49,49,44);
  
  bezier(10,10,8,10,1,7,6,1);
  bezier(10,10,10,8,7,1,1,6);
  
  bezier(10,40,8,40,1,43,6,49);
  bezier(10,40,10,42,7,49,1,44);
  
  bezier(40,10,42,10,49,7,44,1);
  bezier(40,10,40,8,43,1,49,6);
    
 stroke(255);
 line(0,0,0,50);
 line(50,0,50,50);
 line(0,0, 10,0);
 line(40,0, 50,0);
 strokeWeight(3);
 line(0,50,50,50);
 line(0,0,0,50);
 line(0,0,50,50);
 line(0,50,50,0);
 line(25,0,25,50);
 line(0,25,50,25);
 strokeWeight(1);
 stroke(0);
}

  

void accents(){
  line(20,15, 30,35);
  line(30,15, 20,35);
}
  

void angles(){
  line(10, 10, 10, 0);
  line(0, 10, 10, 10);
  line(10, 50, 10, 40);
  line(0, 40, 10, 40);
  line(40, 40, 50, 40);
  line(40, 40, 40, 50);
  line(40, 10, 40, 0);
  line(40, 10, 50, 10);
}

void Hex(){
  line(20, 15, 30,15);
  line(20, 15, 15,20);
  line(30, 15, 35,20);
  line(15, 30, 15,20);
  line(35, 30, 35,20);
  line(35, 30, 30,35);
  line(15, 30, 20,35);
  line(20,35,30,35);
  
}
  
void halfHex(){
  line(20,40,30,40);
  line(20,40,15,45);
  line(35,45,30,40);
  line(15,45, 15, 50);
  line(35,50, 35, 45);
  
  line(20,10,30,10);
  line(20,10,15,5);
  line(35,5,30,10);
  line(35,5, 35, 0);
  line(15,5, 15, 0);
  
  line(10,20,10,30);
  line(10,20,5,15);
  line(5,35,10,30);
  line(5,35, 0, 35);
  line(5,15, 0, 15);
  
  line(40,20,40,30);
  line(40,20,45,15);
  line(45,35,40,30);
  line(45,15, 50, 15);
  line(50,35, 45, 35);
  
}
//particle code modified from example in processing.org
//http://processing.org/examples/bouncybubbles.html


class Ball {

  float x, y;
  float diameter;
  int vx = 0;
  int vy = 0;
  int id;
  Ball[][] others;

  Ball(float din, int idin, Ball[][] oin) {
    x = 25;
    y = 25;
    diameter = din;
    id = idin;
    others = oin;
  } 



  void move(int moving) {
    if (mouseX != 0) {
      dirX = mouseX-width/2;
      dirX = dirX/ abs(dirX);
      if ( moving == 1) {
        dirX = - dirX;
      }
    }
    if (mouseY!=0) {
      dirY = mouseY-height/2;
      dirY = dirY/ abs(dirY);
      dirY = - dirY;
      if ( moving == 1) {
        dirY = - dirY;
      }
    }

    vx +=dirX;
    vy += dirY;
    x += vx;
    y += vy;
    if (x + diameter/2 > 50) {
      x = 50 - diameter/2;
      vx *= friction;
    }
    else if (x - diameter/2 < 0) {
      x = diameter/2;
      vx *= friction;
    }
    if (y + diameter/2 > 50) {
      y = 50 - diameter/2;
      vy *= friction;
    } 
    else if (y - diameter/2 < 0) {
      y = diameter/2;
      vy *= friction;
    }
  }

  void display() {
    rect(x, y, diameter, diameter);
  }
}

3 October 2013

Looking Outwards- Maryyann Landlord

Hyper(Reality)

This project contains a helmet which allows the user to enter a sort of digital world, surrounding the user in an alternative version of reality through the helmet. The user can navigate through the digital world created by the helmet while still interacting with the physical world outside of the helmet. It creates an odd and curious median between the two states.

I found this project interesting because of the combination between what is real and what is fabricated. The ability of the project to combine the two is very attractive for me. If further explored, the digital world can have certain surprises or friendly characters that the real world doesn’t’ contain. The user can then enter a digital game world, in which the game utilizes the real world to create levels or advances. I think to have those subtle differences in the two worlds will bring about the question of what is reality and what is invented. Is reality what we perceive in our own minds about the world of which we have control over or is it simply an observation that we accept?

I think a very effective part of this project was the way the digital world look. It had a much digitized effect in the way the image is rendered. The artist of this piece, Maxence Parache seems to involve his artwork in a lot of digital design. His website reveals different projects such as Data Visualizatino of Holborn Traffic, The Yagi Project, which can be used to listen to frequencies from satellites by relying on radio messages sent from hundreds of kilos away.

It is definitely a project of high potential and can be utilized in games or digitalized designs.

Hyper(reality) – Geffrye Museum from Maxence on Vimeo.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Dodoecaudion

Dodoecaudion is an audiovisual controller assembled from infrared distance sensors, arduinos, Bluetooth, processing and osc. It manipulates sounds as people glide their hands across the openings of the spatial suspended device. The source code is open and the CAD documentation and schematics as well.

The most intriguing part of this piece for me is its geometric simple design. The design is clean and pristine and gives it an almost foreign feel because it is so simple yet creates such beautiful music. I think the inside of the piece could have been more carefully designed so the inside could be just as simple in appearance as the outside. Of course, since the piece is still in its alpha stage at the moment, there are still incomplete qualities to the piece that will be changed before it goes on production.

The artists behind Dodoecaudion create a lot of musical based interactive products, such as their panGenerator-Peacock, which is an interactive kinetic audiovisual installation shakes three panels of lights as the piece produces chaotic sounds.

DODECAUDION from ◥ panGenerator on Vimeo.

panGenerator – PEACOCK from Jakub Koźniewski on Vimeo.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Radiance

I found this project very gorgeous. Radiance is a wall consisting of acrylic flower petals that light up according to the motion of people walking around. It was assembled and installed on a standalone fireplace in the house of a family who rarely used their fireplace. The team proposed an idea of orating and lighting up the family’s life by installing this interactive light piece on top of the brick fireplace.

Although the design is fairly simplistic, I think the idea behind the piece is very compelling and beautiful. From an ordinary bland fireplace that was rarely used, the team transformed it into an art piece that would bring the family together as it lit up when members walked around the piece. I think it was a great touch to make the lights light up based upon movement, which engages interaction with the piece. By having an irregular lighting effect, the flower petals appear almost alive.

Upon exploring their website(http://www.projectione.com/), I recognized that they used a lot of lighting in their pieces and have a distinct signature of assembling many little repeated pieces to create a larger piece. I think an improvement they could have made to the Radiance piece was to have the flowers glow slightly a different color at night or during different times of the day. I think by having that variety, the piece would gain even more life. Many flowers, such as day lilies, open during the day and close at night, while other flowers just live for one day and die off in the night while other buds replace them. By giving the wall of acrylic flowers more life creates a fantastical and curious feel just as it would when one blurs the line between a manmade object and an organic living object.

Radiance from PROJECTiONE on Vimeo.

3 October 2013

move fish get out of the way

./wp-content/uploads/sites/2/2013/10/really.pdf

I heavily borrowed Golan’s repulsion code, mostly because I had to start a new one today (the one I was working on was on my USB drive, which I had left in a studio class in a locked room… sigh). Because of this, I was determined to at least make the curves look nice. So I spent a lot of time on various fluid shapes I could make, something that would look interesting laser cut:

Then with the code, I abused curveVertex to death. That’s basically it, other than some adjustments for the fishies to not intersect with the big fish for the sake of the laser cutter. I also really wanted to make the fishies naturally shy away from the big fish, but didn’t have time to implement it… and I figured that it wouldn’t even show up on the lasercut screen anyway.

//code from Golan Levin; modified for fishies

ArrayList myFishys;

void setup() {
  size(600, 600);
  myFishys = new ArrayList();
  for (int i=0; i<100; i++) {
    float rx = random(width);
    float ry = random(height);
    while(rx > 50 && (ry > 100 && ry < 500)){
      rx = random(width);
      ry = random(height);
    }
    myFishys.add( new Fishy(rx, ry));
  }
}

void draw() {
  background (255);
  stroke(0);
  noFill();
  bigfish();
  float mutualRepulsionAmount = 1.5;
  for (int i=0; i 1.0) {
        float componentInX = dx/dh;
        float componentInY = dy/dh;
        float proportionToDistanceSquared = 1.0/(dh*dh);
        float repulsionForcex = mutualRepulsionAmount * componentInX * proportionToDistanceSquared;
        float repulsionForcey = mutualRepulsionAmount * componentInY * proportionToDistanceSquared;
        ithFishy.addForce( repulsionForcex, repulsionForcey); // add in forces
        jthFishy.addForce(-repulsionForcex, -repulsionForcey); // add in forces
      }
    }
  }
  for (int i=0; i
void bigfish() {
  pushMatrix();
  translate(width/2+200, height/2+20);
  scale(2);
  line(-180, 0, -70, 0);
  bigfishhead();
  bigfishbones();
  pushMatrix();
  translate(0, -20);
  bigfishtail();
  popMatrix();
  popMatrix();
}
void bigfishtail() {
  tail();
  pushMatrix();
  translate(5, 10);
  scale(0.7);
  tail();
  popMatrix();
  pushMatrix();
  rotate(0.5);
  translate(40, 80);
  tail();
  popMatrix();
}
void tail() {
  beginShape();
  curveVertex(-120, 0);
  curveVertex(-120, 0);
  curveVertex(-125, -5);
  curveVertex(-60, -40);
  curveVertex(30, -50);
  curveVertex(30, -50);
  endShape();
  beginShape();
  curveVertex(30, -50);
  curveVertex(30, -50);
  curveVertex(-60, -20);
  curveVertex(-120, 0);
  curveVertex(-120, 0);
  endShape();
}
void bigfishhead() {
  beginShape();
  curveVertex(-170, -40);
  curveVertex(-170, -40);
  curveVertex(-190, -20);  
  curveVertex(-200, 0);
  curveVertex(-190, 20);
  curveVertex(-170, 40);
  curveVertex(-170, 40);
  endShape();
  beginShape();
  curveVertex(-170, -40);
  curveVertex(-170, -40);
  curveVertex(-180, 0);
  curveVertex(-170, 40);
  curveVertex(-170, 40);
  endShape();
}
void bigfishbones()
{
  topbone();
  pushMatrix();
  for (int i = 0; i < 5; i++) {
    scale(0.85);
    topbone();
  }
  popMatrix();
  bottombone();
  for (int j = 0; j< 5; j++) {
    scale(0.85);
    bottombone();
  }
}
void topbone() {
  beginShape();
  curveVertex(-150, -15);
  curveVertex(-150, -15);
  curveVertex(-155, -17);
  curveVertex(-147, -35);
  curveVertex(-150, -42);
  curveVertex(-142, -55);
  curveVertex(-130, -95);
  curveVertex(-125, -100);
  curveVertex(-125, -100);
  endShape();
  beginShape();
  curveVertex(-125, -100);
  curveVertex(-125, -100);
  curveVertex(-150, -15);
  curveVertex(-150, -15);
  endShape();
}
void bottombone() {
  beginShape();
  curveVertex(-150, 20);
  curveVertex(-150, 20);
  curveVertex(-140, 45);
  curveVertex(-135, 53);
  curveVertex(-135, 53);
  endShape();
}
class Fishy {
  float size;
  float px;
  float py;
  float vx;
  float vy;
  float damping;
  boolean bLimitVelocities = true;

  // Constructor for the Fishy
  Fishy (float x, float y) {
    px = x;
    py = y;
    vx = vy = 0;
    damping = 0.96;
    size = random(0.5, 1.5);
  }

  // Add a force in. One step of Euler integration.
  void addForce (float fx, float fy) {
    float ax = fx;
    float ay = fy;
    vx += ax;
    vy += ay;
  }

  // Update the position. Another step of Euler integration.
  void update() {
    vx *= damping;
    vy *= damping;
    limitVelocities();

    px += vx;
    py += vy;
  }

  void limitVelocities() {
    if (bLimitVelocities) {
      float speed = sqrt(vx*vx + vy*vy);
      float maxSpeed = 10;
      if (speed > maxSpeed) {
        vx *= maxSpeed/speed;
        vy *= maxSpeed/speed;
      }
    }
  }

  void render() {
    noFill();
    pushMatrix();
    translate(px, py);
    fishy();
    endShape();
    popMatrix();
  }

  void fishy() {
    scale(size);
    beginShape();
    curveVertex(-10, 0);
    curveVertex(-10, 0);
    curveVertex(-5, -2);
    curveVertex(0, -3);
    curveVertex(5, -2);
    curveVertex(10, 0);
    curveVertex(10, 0);
    curveVertex(13, -3);
    curveVertex(13, -3);
    endShape();
    beginShape();
    curveVertex(-10, 0);
    curveVertex(-10, 0);
    curveVertex(-5, 2);
    curveVertex(0, 3);
    curveVertex(5, 2);
    curveVertex(10, 0);
    curveVertex(10, 0);
    curveVertex(13, 3);
    curveVertex(13, 3);
    endShape();
  }
}

3 October 2013

Ticha-Sound Repulsion (updated)

./wp-content/uploads/sites/2/2013/10/waves.pdf
./wp-content/uploads/sites/2/2013/10/waves-3.pdf

UPDATE: Hopefully the first one will lasercut now.

When I approached the project initially, I really wanted to create a cellular simulation of sorts – I got as far as creating hideous ‘blobs’ formed by attaching various Spring objects to a centroid particle… but they looked so terrible (and defied too much physics) that I decided to scrap the idea completely and try something fresh. I was interested in making another semi-interactive piece – and as I had recently discovered that Processing supported audio, I decided to scour the internet for java libraries that potentially supported audio input. Fortunately, there existed an AudioInput Class that was easy to understand and was suitable for my purposes (kudos to CreativeCoding.org for introducing it to me).

Because I was creating a system that was affected by sound, I wanted to make a structure that visually cohered to the concept of sound, audio, or music. The final design ended up resembling a stylized vinyl record, which I am quite satisfied with. Additionally when the arcs get propagated outwards they somewhat resemble radio waves, which is another interesting effect. But despite how I am satisfied with how it turned out visually, I have mixed feelings towards its functionality. To maintain a certain degree of order, I initially intended to create springs that connected each arc to the centroid, so that after they had stretched out to a certain extent they would regain their initial positions. Perhaps it can be an adjustment I will work on in the future.

The code is here, but the application itself must be downloaded to work properly. I should also add that the PDF recording option was adapted from Michelle’s clever recording trick, which comes in handy for ‘screenshotting’ Processing output windows. 😀

3 October 2013

Rain Water-Maryyann Landlord

In the beginning, I wanted started with the idea of creating a 3 dimensional object from the 2 dimensional cut outs. It would be cut out into separate parts and then assembled after the pieces were popped out. My idea was a fish, with 9 circular disks as “ribs” and supporting beams going around the body as well as fins and a tail. However, after making some calculations, I realized how precise the measurements would have to be and the fact that aesthetically speaking, a generated pattern of sorts would have a better visual appeal.

Images of my idea:

Next I explored other areas that would create a more visually pleasing piece. Since we recently learned about particles, I decided to incorporate that into my piece. I thought about the effect of rain dropping on the ground on a rainy day. From there my thoughts wondered towards the comparisons of the effects of water. How could I show contrasts between the same element? I also wanted to explore text because I had never used text in my pieces before.

Following that thought, I decided to represent rain drops using letters of the alphabet,which was the first appearance of water. The “rain” fell slightly at an angle, at different speeds which gave it the calming appearance of rain. I needed more types of water. So, I placed an invisible pool of water at the bottom of the piece, which gathered the rain letters and slowly dispensed them to the bottom, where they were recycled back as rain. I thought it was interesting that the letters, which begin as rain(water) fall into another pool of water, but then gain the appearance of a solid object while the viewer still understood them as rain drops.

This is a fairly simple design which I think creates more satisfaction as a animated piece than a static one. A single photo merely doesn’t contain the comparison of the water against water as the moving piece contains. I do understand though, laser cutting letters may become a problems due to the little number of closed shapes that come with the alphabet, but I think it’ll be interesting to see how it plays out.

use the arrow keys to see it animate:

./wp-content/uploads/sites/2/2013/10/rain.pdf

update:

After downloading the geomerative library, I used it to tweak my code so that all the falling letters became outlines. Now, the laser cutting will be able to cut around the shape and they will become visible. One problem I realized I had after first remaking the piece, was that certain letters would have huge holes because of the way the letters connected to themselves. So, I changed the ending to the letters and reconnected it to another point and therefore leaving another space for the laser cutting to go around. I added a phrase as well in the various letters so that when people look closely, they will find a present surprise. Another add on I implemented was a repulsion force the letters had towards every other letter. However, because the library and the number of letters made the code run quite slowly, the repulsion didn’t work as well as I wanted it to. I do hope that after changing the code, the laser cutting will cut the pdf correctly.

updated:

./wp-content/uploads/sites/2/2013/10/rain1.pdf

./wp-content/uploads/sites/2/2013/10/rain2.pdf

./wp-content/uploads/sites/2/2013/10/rain3.pdf