itp

NOC final project

admin — Thu, 26 Apr 2012 04:52:11 +0000

We based the idea in balance games, and we wanted to make some characters (like my midterm project) that the user has to balance to move them from one box to another, trying to not let the characters fall down between the boxes.

Combining a project of EunYoung and my midterm we create a device where one or two users can play, however because of the time we only made one box for now. The project consists in a box that have a transparent plane where we project, and it can rotate with a pivot in the middle that is also a potentiometer that can give you different values according to the angle of the plane. In the original project she used this like a wall, and she projected light from the inside. Now we set up a project on the floor, inside the box which has a height of 1.20 meter more or less.

The sketch was developed with processing using toxiclibs library to create the characters and movements of them. Every character owns a body and a head that are respectively a big particle surrounded by little ones joined by springs to make them appear like feet and hair. Also the eyes and the mouth are particles joined to the body and head by invisible springs. The eyes are scaled according to the timer with a random factor to make all the characters blink in different times, and the mouth are scaled according to the value of the potentiometer.

Also, according to the potentiometer we added a force that change with this lecture, that is positive or negative depending of the axis in the middle where the movable plane can rotate. This force is amplified by the size of every character to make the effect of different mass for different sizes.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// Eunyoung Kang + Marcela Godoy // The Nature of Code // final project spring 2012 // Based on "Simple two particles and spring example" by D. Shiffman // The Nature of Code // // Spring 2012


import netscape.javascript.*;

import toxi.physics2d.*;

import toxi.physics2d.behaviors.*;

import toxi.geom.*;
import ddf.minim.*;
Minim minim;

AudioPlayer sound;
import fullscreen.*;

FullScreen fs;
// Reference to physics world

VerletPhysics2D physics;
int numberBlobs = 5; //declaring the elements of array

Blob[] blobs= new Blob [numberBlobs]; //declaring the array
color[] mycolours = {color(0,204,242),color(97,200,60),color(255,205,0),color(255,128,10),color(255,81,130),color(183,106,253)};
void setup() {

size(500, 500);

smooth();

frameRate(30);
//  fs = new FullScreen(this);

//  fs.enter();
// Initialize the physics

physics=new VerletPhysics2D();

minim = new Minim(this);

sound = minim.loadFile("s_2.wav");
// This is the center of the world

Vec2D center = new Vec2D(width/2, height/2);

// these are the worlds dimensions (50%, a vector pointing out from the center in both directions)

Vec2D extent = new Vec2D(width/2, height/2);
// Set the world's bounding box

physics.setWorldBounds(Rect.fromCenterExtent(center, extent));
for (int i=0; i< numberBlobs;i++) {

blobs [i] = new Blob(random(width), random(50, height-50), random(40,80));
}
}
void draw() {
background(0);
//display all the Blobs

for (int i = 0; i< numberBlobs; i++) {

fill(mycolours[i%(mycolours.length)]);

blobs[i].display(mycolours[i]);
}
}
class Blob {
ArrayList

allParticles;

ArrayList

allFace;

ArrayList allSprings;
Particle body, head, n_eye1, n_eye2, n_mouth; //nucleo, head, eyes

float large;
//define constructor

Blob(  float x, float y, float sizeBlob){
//setup

int particles_number= 30;

float angle=radians(random(360));

float u = radians(360/particles_number);

float v;

large = sizeBlob; //dimension connections

float _x = x;

float _y = y;
allParticles = new ArrayList

();

allFace = new ArrayList

();

allSprings = new ArrayList();
////////////// BODY
body = new Particle(_x,_y);
body.r = large*1.3; // ratio big circle

physics.addBehavior(new AttractionBehavior(body, large*0.7, -1));
head = new Particle(_x,_y);
physics.addParticle(body);
head.r = large*1.1;
n_eye1 = new Particle(head.x,head.y);

n_eye1.r = large*0.06;
n_eye2 = new Particle(head.x,head.y);

n_eye2.r = large*0.06;
n_mouth = new Particle(head.x,head.y);

n_mouth.r = 0;
VerletSpring2D spring_body = new VerletSpring2D(body, head, large*0.4, 0.1); //join the body and face

VerletSpring2D spring_eye1 = new VerletSpring2D(body, n_eye1, large*0.5, 0.1);

VerletSpring2D spring_eye2 = new VerletSpring2D(body, n_eye2, large*0.5, 0.1);
VerletSpring2D spring_eye1_1 = new VerletSpring2D(head, n_eye1, large*0.1, 0.1);

VerletSpring2D spring_eye2_2 = new VerletSpring2D(head, n_eye2, large*0.1, 0.1);
VerletSpring2D spring_eyes = new VerletSpring2D(n_eye2, n_eye1, large*0.15, 0.1);

VerletSpring2D spring_mouth = new VerletSpring2D(body, n_mouth, large*0.3, 0.1);

VerletSpring2D spring_mouth2 = new VerletSpring2D(n_eye1, n_mouth, large*0.18, 0.1);

VerletSpring2D spring_mouth3 = new VerletSpring2D(n_eye2, n_mouth, large*0.18, 0.1);
physics.addSpring(spring_body);

physics.addSpring(spring_eye1);

physics.addSpring(spring_eye2);

physics.addSpring(spring_eye1_1);

physics.addSpring(spring_eye2_2);

physics.addSpring(spring_eyes);

physics.addSpring(spring_mouth);

physics.addSpring(spring_mouth2);

physics.addSpring(spring_mouth3);
////////////// END BODY
//////////////////////////physics.addParticle(body);

for (int i= 0; i< particles_number; i++) {
v = large + 3 * sin(u*i*(particles_number/2.5));

Particle p = new Particle(x + v * cos(angle + i*u), y + v * sin(angle + i*u)); //arrange different ratios in a sinusoidal way

p.r = random(large*0.05,large*0.2);

physics.addParticle(p);

allParticles.add(p);

physics.addBehavior(new AttractionBehavior(p, 10, -1));
// add a spring between body and every p
VerletSpring2D spring = new VerletSpring2D(body, allParticles.get(i), v-large*0.25, 0.01);

physics.addSpring(spring);

allSprings.add(spring);
}

//////////////////////////end physics.addParticle(body);
//////////////////////////physics.addParticle(head);
for (int i= 0; i< 30; i++) {           v = large*0.65 + 10 * sin(u*i*(30/5.5));     Particle p = new Particle(x + v * cos(angle + i*u), y + v * sin(angle + i*u)); //arrange different ratios in a sinusoidal way     p.r = random(large*0.02,large*0.1);     physics.addParticle(p);     allFace.add(p);     p.r=random(1,4);     physics.addBehavior(new AttractionBehavior(p, 10, -1));     // add a spring between n2 and every p          VerletSpring2D spring_face = new VerletSpring2D(head, allFace.get(i), v, 0.01);     physics.addSpring(spring_face);     allSprings.add(spring_face);                      }     //////////////////////////end physics.addParticle(head);      }      //end define constructor      void display(color c){          physics.update();          for (Particle p : allParticles) {     p.displayParticles();      stroke(c);     strokeWeight(3);     line(body.x, body.y, p.x, p.y);          }          for (Particle p : allFace) {     p.displayParticles();      stroke(c);     strokeWeight(0.5);     line(head.x, head.y, p.x, p.y);            }           body.displayParticles();   head.displayParticles();   n_eye1.displayFace(floor(large));   n_eye2.displayFace(floor(large));      Vec2D f = new Vec2D(0,(large*0.05*(mouseY-height*0.5)/10));   body.addForce(f);      float boca = abs(mouseY-height*0.5);   float bocaMap = map(boca, 0,200,0,large*0.2);   println(bocaMap);           if (body.y > height-large*0.5){

//    body.y = height;

//    body.lock();

n_mouth.displayMouth(4);

}
else if (body.y < large*0.5){ //    body.y = 0; //    body.lock();     n_mouth.displayMouth(4);   }         else{      n_mouth.displayMouth(bocaMap);      if(bocaMap>3){

sound.play();

}else{

sound.rewind();
}

}
}

}
class Particle extends VerletParticle2D {
float r;
Particle(float x, float y) {

super(x,y);

}
// All we're doing really is adding a display() function to a VerletParticle

void displayParticles() {

//fill(0,204,242);

noStroke();

ellipse(x,y,r,r);

}
void displayFace(int delayEyes) {
float time = millis()/(100+delayEyes);

float blinkAmount = time%20;

int escala =0;

if(blinkAmount==0 || blinkAmount==2) escala=0;

else escala=1;

fill(0);

noStroke();

ellipse(x,y,escala*r,escala*r);
}
void displayMouth(float escala) {
fill(0);

noStroke();

ellipse(x,y,escala,escala);
}
}

final project idea

admin — Wed, 04 Apr 2012 16:40:17 +0000

I’m working in this project with Eunyoung, because we both wanted to make something physical and interactive.

We know we don’t have enough time so we thought in the idea to recycle-combine some other projects. therefore we decide to use a previous project of Eunyoung that consists in boxes that have a transparent plane with a pivot in an axis in the middle that is also a potentiometer and read the angle of rotation of the panel. In the original project she used this like a wall, and she projected light from the inside. Now we would like to use it like a table composed of four of these boxes that will show in the transparent panel the projection of the sketch that we are going to develop as a final project.

We based the idea in balance games, and we would like to try to make some balls or characters (like my midterm project) that the user has to move in order to put these in some holes or move through some path. The idea is when you start to play all these characters are in a corner and you have to try to not let the characters fall down between the boxes.

http://hackawii.com/wii-balance-board-labyrinth-game/

here there are some sketches:

assignments

admin — Wed, 07 Mar 2012 18:11:27 +0000

sinusoid function:

import netscape.javascript.*;

float angle = 0;
float speed = 0.8;
float x = 0;
float y = 0;
float y0 = 100;
float w = random(5,30);

void setup (){
size (500,200);
noStroke();
smooth();
background(0);
}

void draw(){
noStroke();
fill(0,7);
rect(0,0,width,height);
fill (255, 100);
angle += speed;
if (x x ++;
}else{
x = 0;
}

y= y0 + 10 * sin(angle/w);
ellipse(x,y,20,20);

}

drag and drop, torque and friction:

particles toxiclibs:

nature of code midterm

admin — Wed, 07 Mar 2012 05:15:58 +0000

some references:

previous work:

one big particle is attached with many others in a “random” position around the big one….to get different ratios i distributed the position using a sinusoidal function to variate the ratio in some range.
The little particles also are attached between them with a spring that is not drawn in the sketch with lines, like the springs that are connecting the big particle with the little ones.
For the character, the little particles take a random range for the ratio, between 1 and 20….and for the head between 1 and 3. The body is formed by 2 big particles connected by a spring very short, that’s why they never separate each other too much.

code:

// Marcela Godoy
// The Nature of Code // midterm project spring 2012
// Based on “Simple two particles and spring example” by D. Shiffman
import netscape.javascript.*;
import toxi.physics2d.*;
import toxi.physics2d.behaviors.*;
import toxi.geom.*;

// Reference to physics world
VerletPhysics2D physics;

ArrayList
allParticles;
ArrayList
allFace;

ArrayList allSprings;
ArrayList allConnections;

Particle n1; //nucleo
Particle n2; //nucleo
int particles_number= 60;
float angle=radians(random(360));
float u = radians(360/particles_number);
float v;
PImage b;

void setup() {
size(400, 400);
smooth();
frameRate(30);
b = loadImage(“c.png”);

allParticles = new ArrayList
();
allFace = new ArrayList
();
allSprings = new ArrayList();
allConnections = new ArrayList();

// Initialize the physics
physics=new VerletPhysics2D();
physics.addBehavior(new GravityBehavior(new Vec2D(0, 0.09)));

// This is the center of the world
Vec2D center = new Vec2D(width/2, height/2);
// these are the worlds dimensions (50%, a vector pointing out from the center in both directions)
Vec2D extent = new Vec2D(width/2, height/2);

// Set the world’s bounding box
physics.setWorldBounds(Rect.fromCenterExtent(center, extent));

fill(0, 100);
noStroke();
float x = random(width);
float y = 0;

n1 = new Particle(x,y);
n1.r = 150;
n1.opacity=0;

//physics.addBehavior(new AttractionBehavior(n1, width, 0.1));

n2 = new Particle(random(width),random(height));

VerletSpring2D spring_n = new VerletSpring2D(n2, n1, 40, 0.1);
physics.addSpring(spring_n);

//////////////////////////physics.addParticle(n1);

for (int i= 0; i< particles_number; i++) {

v = 100+5*sin(u*i*(particles_number/2.5));
Particle p = new Particle(x + v * cos(angle + i*u), y + v * sin(angle + i*u)); //arrange different ratios in a sinusoidal way
physics.addParticle(p);
allParticles.add(p);

// add a spring between n1 and every p

VerletSpring2D spring = new VerletSpring2D(n1, allParticles.get(i), v-20, 0.01);
physics.addSpring(spring);
allSprings.add(spring);

// add a spring between p’s

VerletParticle2D pi = (VerletParticle2D) allParticles.get(i);
for (int j = 0; j < i; j++) {
VerletParticle2D pj = (VerletParticle2D) allParticles.get(j);
VerletSpring2D connection = new VerletSpring2D(pi, pj, 100, 0.00001);
physics.addSpring(connection);
allConnections.add(connection);
}

}//////////////////////////physics.addParticle(n1);

//////////////////////////physics.addParticle(n2);

for (int i= 0; i< 150; i++) {

v = 90+5*sin(u*i*(particles_number/5.5));
Particle p = new Particle(x + v * cos(angle + i*u), y + v * sin(angle + i*u)); //arrange different ratios in a sinusoidal way
physics.addParticle(p);
allFace.add(p);
p.r=random(1,3);

// add a spring between n1 and every p

VerletSpring2D spring2 = new VerletSpring2D(n2, allFace.get(i), v-20, 0.01);
physics.addSpring(spring2);
allSprings.add(spring2);

// add a spring between p’s

VerletParticle2D pi = (VerletParticle2D) allFace.get(i);
for (int j = 0; j < i; j++) {
VerletParticle2D pj = (VerletParticle2D) allFace.get(j);
VerletSpring2D connection2 = new VerletSpring2D(pi, pj, 100, 0.00001);
physics.addSpring(connection2);
allConnections.add(connection2);
}

}//////////////////////////physics.addParticle(n2);

//n1.lock();

}

void draw() {

// Update the physics world
physics.update();

background(255);
float angle2 = u;

for (Particle p : allParticles) {
p.display();
stroke(0,40);
line(n1.x, n1.y, p.x, p.y);
}

for (Particle p : allFace) {
p.display();
stroke(0,40);
line(n2.x, n2.y, p.x, p.y);
}

n1.display();
n2.displayFace();

float distance = dist(n2.x, n2.y, mouseX, mouseY);
if(distance < 100){
n2.lock();
n2.x = mouseX;
n2.y = mouseY;
n2.unlock();

}

}

class Particle extends VerletParticle2D {

float r = random(1,20);
float opacity = 0;

Particle(float x, float y) {
super(x,y);
}

// All we’re doing really is adding a display() function to a VerletParticle
void display() {
fill(0 + opacity);
noStroke();
ellipse(x,y,r,r);

}

void displayFace() {
imageMode(CENTER);
image(b, x,y, 120, 120);

}

}

pop-up +1

admin — Wed, 22 Feb 2012 00:50:43 +0000

based on:

assignment_01

admin — Sat, 04 Feb 2012 22:57:03 +0000

I wanted to make something like the Joy Division album cover,

but it’s difficult to know where to fold every part and the page still works…..i should glue every part separately, so i started with this model…..drawing several parallel lines and then random diagonals that cross them, then i cut every parallel following the drawing. When this was finished i glued to a page and i folded everything, so the mountains where defined by the page fold.

thesis proposal

admin — Fri, 03 Feb 2012 14:26:49 +0000

transformable architecture

can technology change the way of thinking and doing architecture?
in my opinion, using technology buildings should be organisms capable to transform and move as a result of the interaction with people and their practices that are constantly changing.
This study is a research to design and develop a modular, structural and active piece that can generate an interactive surface, something like a “kinetic brick”.

Brief Description.

transformable architecture is a series of experiments exploring math, geometry, mechanisms and ways to generate an interactive surface. Using digital tools and material properties to create a light, modular, and self-structured prototype.

Why do this idea?

I started working in this project using digital tools to create a self-structured, modular and light surface to cover big spaces. According to material properties that I studied previously I tried to solve the question: how to make strong a “weak” (light) material?
Observing steel sheets in a wall container, I started exploring folds and then Origami Tessellations that could be useful in architecture. Studying the behavior of these patterns i realized that I could generate different shapes with the same prototype, so I wondered why still thinking of this as something static? and then, why still thinking architecture as something static?
Then I realized that I had never before studied how the things can move, because in architecture we start from the base that everything must be static, but why should buildings remain statics 100 or 200 years if nowadays people is constantly and quickly changing?

Research Plan.

shape:
The first weeks i want to explore different models, geometries and patterns useful in architecture and the potentials of folds. Study the way that they move and try to be an expert knowing the actions and reactions of every one of its components. To do this i will use digital 3D software and real prototypes using digital fabrication machines.

mechanism:
After I have chosen or designed a shape i want to develop a mechanism that can move and stop the movement of this kinetic module, because if i want to structure the surface i have to make it rigid but flexible to adopt different states. The study of this mechanism it will be supported also using digital tools to design, simulate and fabricate.

interaction:
In the last weeks i want to explore the way that this mechanism can interact with people. Studying a sensor or a mechanical way to move the module, and if this movement is triggered by human body, activities or environment.

By Thesis Week I intend to have a kinetic prototype that can be replicated and assembled to generate an interactive surface that can be used to cover different urban activities.
Also the digital documentation of this study and other potential shapes that can be developed to continue the exploration of transformable architecture.

Need to Know….

admin — Sun, 29 Jan 2012 18:44:38 +0000

What’s your approach?

What do you need to know and how will you find out?

pattern studies (math, geometry)

mechanism:

http://www.robives.com/mechs

interaction (sensor?)

What resources do you know of?

Pier L. Nervi

Buckminster Fuller:

Ron Resch:

material potency:

paper works:

Folding Techniques For Designers: Basic Concepts

Who should you talk to about it?

Dustyn Roberts – mechanism class
Ithai Benjamin – puppets class
Adi Maron – itp alumni
chika – itp resident

What help do you need?

previous research – models

in itp i’ve been making different models with different materials, thinking in something that can be a deployable structure.

previous research

admin — Fri, 27 Jan 2012 18:40:33 +0000

i started working in this project thinking about to make:

architecture, lightness, modular, transportable, self-structured, build from the material properties.

then i thought how to make strong a “weak” (light) material, like steel sheets in a wall container and realized that when you fold it, you can make it stronger. So i started researching Origami Tessellations and how this can be useful in architecture.

Doing these origami models i realized that i could make different shapes that can cover an architectural space so,the question was:

why still thinking of this as something static?

and then….

why still thinking architecture as something static?

Data Rep Final

admin — Sat, 10 Dec 2011 15:36:30 +0000

This visualization shows the purposes to experiment with animals in UK in 2009, and also the kind of animals and the amount of them in every purpose, according to the data that i got in http://www.guardian.co.uk/news/datablog/2009/jul/21/animal-research.
The size of every circle indicates the amount of animals used in a purpose (TRACKS) and then, the fraction of colors indicate the kind of animals and the number of that kind of animals compared to the total amount used for a specific purpose (MUSIC NOTES).

The whole composition is a kind of album with songs, where every song is a human purpose to experiment with animals.

In every track, the kind of animal is a specific prerecorded sound. The amount of animals compared with the total is related with the amount of loops of every sound and the kind of beat that the song has.

The idea is to get songs made them with prerecorded animal sounds, that sounds like this:

I made a song with animal sounds by FoodsAreBombs.

DATA:

http://www.guardian.co.uk/news/datablog/2009/jul/21/animal-research

Animal experiments in numbers

There are more experiments on animals in the UK than ever before.

Animal research: Marmoset monkeys
Marmoset monkeys used in animal research are given marshmallows at a testing centre.

Photograph: Graeme Robertson

Figures out today show the largest rise in the use of animals in medical research since modern records began in 1986. The number of procedures involving animals rose by 454,000 in 2008 compared with the previous year.

The rise reflects more biomedical research in Britain, particularly studies that use genetically modified mice to study the roles of genes in living organisms. The annual Home Office report covers a range of procedures, including the breeding of genetically modified animals, taking blood and tissue samples from animals, and more invasive procedures to the brain and treatments for incurable diseases such as cancer and Parkinson’s disease. Many animals are used for more than one procedure, so the number of animals involved in medical research is considerably smaller.

DATA: full details of animal experiments as a spreadsheet

Scientific procedures on animals

Numbers in 000s. Click heading to sort
Species	2003	2004	2005	2006	2007	2008
SOURCE: Home Office
Mouse	1816.9	1919.1	1961	2067.1	2221.9	2418.6
Rat	496.4	464.7	424.5	406.2	385.7	355.4
Other rodent	48.1	37.5	41.5	37.6	37.3	34.5
Rabbit	25.3	21.7	22.8	20.4	19.6	17.1
Carnivore	10.9	10.7	10.1	9.8	9	8.9
Ungulate (eg deer)	75.5	75.1	61.4	55.8	48.2	54.9
Primate	4.8	4.2	4.7	4.2	4	4.6
Other mammal	1.7	2.4	2.3	1.7	1.6	1
Bird	121.6	105.3	113.2	114.4	127.6	123.3
Reptile/Amphibian	16.6	19.5	21.8	20.8	19	32.8
Fish	174	194.6	232.9	274.1	327.6	605.2
Total	2791.8	2854.9	2896.2	3012	3201.5	3656.1

PROCESSING CODE (in progress):

float[] track1; float[] track2; float[] track3; float[] track4; float[] track5; float[] track6; float[] track7; float[] track8;

import ddf.minim.*; import processing.serial.*;


import fullscreen.*;

//FullScreen fs;
Minim minim;

//////////////////////////////////////////music files number of animals

int totalSounds = 20;

AudioPlayer[] sound = new AudioPlayer[totalSounds];

boolean down = false;

AudioPlayer beat;

AudioPlayer beat_short;
int letras[] = {77,78,66,86,67,88,90,76,75,74,72,71,70,68,83,65,80,79,73,85};
//char letras[] = {'M','N','B','V','C','X','Z','L','K','J','H','G','F','D','S','A','P','O','I','U'};
//////////////////////////////////////////ratio = amount of animals in every purpose

float[] ratio = new float[8];
float[] ini = new float[8];

float[] r = new float[8];

float[] s = new float[8];
int animalNumber;

int[] colorAnimal = new int[22];
Serial port;
void setup(){

  size(1280,800);

  background(255);

  smooth();
//  fs = new FullScreen(this);

//  fs.enter(); 
  minim = new Minim(this);
port = new Serial(this, Serial.list()[0], 9600);
port.write('R');
beat = minim.loadFile("beat2.wav");

beat_short = minim.loadFile("beat.wav");
//////////////////////////////////////////load the .CSV

  String[] input = loadStrings("animals2.csv");
  animalNumber = input.length;
 for(int i=0; i < input.length; i++){
    String[] splits = input[i].split(",");
//////////////////////////////////////////load sounds

    if (i< totalSounds){

      String name = "a_"+ i  + ".wav";

      sound[i] = minim.loadFile(name);
    }
  colorAnimal[i] = 20 + 10 * (23-i);
    if(i == 0){
//////////////////////////////////////////asign ratio to tracks depending on the amount of animals used

for(int u=0; u < 8; u++){

  ratio[u] = float(splits[u+1]);

}
    }
////////////////////////////////////////////print track names

    if(i==1){

      int posinit = 30;

      fill(0,150);

      text("tracks:", 30, posinit);

      for (int u=1; u < 9; u++){

          fill(0,100);

          text("0"+u+". "+splits[9-u], 30, posinit + 20*u);

     }
   }
    if (i > 1){
////////////////////////////////////////////print animals names
     smooth();

     fill(colorAnimal[i]);

      text(splits[0], 1060, 150 + (20) * (i));
//////////////////////////////////////////first ponit to draw arc

for(int u=0; u < 8; u++){
  float maxR = 2.6; // maximo valor en la cantidad total de animales en todos los propositos

  float maxRR = 700; //maximo valor del radio de la circunferencia mas grande
  s[7-u]=map(float(splits[u+1]),0,100,0,2*PI);

  r[u]=map(ratio[7-u],0,maxR,100,maxRR);
//////////////////////////////////////////print tracks
}
//fill(60 + 1.5 * (23-i), 10 + 11 * (23-i) , 60 + 14 * (23-i));
for(int u=0; u < 8; u++){

   fill(colorAnimal[i]);

    drawtrack(u);

//  //////////////////////////////////////////print white circles

 stroke(255, 100);

  strokeWeight(0.5);

  noFill();

  ellipse(width*0.5, height*0.5,r[u],r[u]);

}
      }

 }
}
void draw(){
  background(255);

  smooth();
  PImage b;

// Images must be in the "data" directory to load correctly

   b = loadImage("cd.jpg");

   image(b, 0, 0);
//////////////////////////////////////////tracks
    if (keyPressed && !down) {

        down=true;
//////////////////////////////////////////track1

        if (key == '1') {
          int loops1[] = {10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

          int sep1 = 900;
for (int i =0; i< 20;i++){

            if (loops1[i] != 0){
              delay(sep1);
              if (loops1[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops1[i]-1);

              sound[i].play(0);

              sound[i].loop(loops1[i]-1);
              for (int u =0; u < loops1[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep1/3);

              }
              }
                delay(sep1);

              } else{

             delay(0);
            }

          }
        }  
//////////////////////////////////////////track2

        if (key == '2') {
          int loops2[] = {9,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0};

          int sep2 = 900;
for (int i =0; i< 20;i++){

            if (loops2[i] != 0){

              delay(sep2);
              if (loops2[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();

              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops2[i]-1);

              sound[i].play(0);

              sound[i].loop(loops2[i]-1);
              for (int u =0; u< loops2[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep2/3);

              }
              }
                delay(sep2);

              }else{

             delay(0);
            }

          }
        }   
//////////////////////////////////////////track3

        if (key == '3') {
          int loops3[] = {6,1,0,0,1,1,1,1,1,1,0,0,1,2,1,0,1,0,0,2};

          int sep3 = 900;
for (int i =0; i< 20;i++){

            if (loops3[i] != 0){

              delay(sep3);
              if (loops3[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();
              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops3[i]-1);

              sound[i].play(0);

              sound[i].loop(loops3[i]-1);
              for (int u =0; u< loops3[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep3/3);

              }
              }
              delay(sep3);
            } else{

             delay(0);
            }

          }
        }   
//////////////////////////////////////////track4

        if (key == '4') {
          int loops4[] = {7,1,0,1,0,0,1,1,0,1,0,1,1,1,0,1,1,1,1,3};

          int sep4 = 900;
for (int i =0; i< 20;i++){

            if (loops4[i] != 0){
              delay(sep4);
              if (loops4[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();
              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops4[i]-1);

              sound[i].play(0);

              sound[i].loop(loops4[i]-1);
              for (int u =0; u< loops4[i]; u++){

                  manodos();

                  port.write(letras[i]);

                  delay(sep4/3);

              }
              }
              delay(sep4);
            } else{

             delay(0);
            }

          }
        }

//

//

//////////////////////////////////////////track5

        if (key == '5') {
          int loops5[] = {2,1,1,1,0,1,1,1,1,1,0,0,1,8,1,0,1,0,0,1};

          int sep5 = 900;
for (int i =0; i< 20;i++){

            if (loops5[i] != 0){

               delay(sep5);
              if (loops5[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();
              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops5[i]-1);

              sound[i].play(0);

              sound[i].loop(loops5[i]-1);
              for (int u =0; u< loops5[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep5/3);

              }
              }
              delay(sep5);
            } else{

             delay(0);
            }

          }
        }

//

//////////////////////////////////////////track6

        if (key == '6') {
          int loops6[] = {9,1,0,1,1,1,1,1,1,0,0,1,0,1,1,0,0,0,1,1};

          int sep6 = 900;
for (int i =0; i< 20;i++){

            if (loops6[i] != 0){
              delay(sep6);
              if (loops6[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();
              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops6[i]-1);

              sound[i].play(0);

              sound[i].loop(loops6[i]-1);
              for (int u =0; u< loops6[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep6/3);

              }
              }
              delay(sep6);
            } else{

             delay(0);
            }

          }
        }

//

//////////////////////////////////////////track7

        if (key == '7') {
          int loops7[] = {8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2};

          int sep7 = 900;
for (int i =0; i< 20;i++){

            if (loops7[i] != 0){
              delay(sep7);
              if (loops7[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();
              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops7[i]-1);

              sound[i].play(0);

              sound[i].loop(loops7[i]-1);
              for (int u =0; u< loops7[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep7/3);

              }
              }
              delay(sep7);
            } else{

             delay(0);
            }

          }
        }   
//////////////////////////////////////////track8

        if (key == '8') {
          int loops8[] = {10,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1};

          int sep8 = 900;
          for (int i =0; i< 20;i++){

            if (loops8[i] != 0){
              delay(sep8);
              if (loops8[i] == 1){

              beat.play(0);

              sound[i].play(0);
              manouno();

              delay(100);

              manodos();
              port.write(letras[i]);
              } else{

              beat_short.play(0);

              beat_short.loop(loops8[i]-1);

              sound[i].play(0);

              sound[i].loop(loops8[i]-1);
              for (int u =0; u< loops8[i]; u++){
                  manodos();

                  port.write(letras[i]);

                  delay(sep8/3);

              }
              }
              delay(sep8);
            } else{

             delay(0);
            }

          }
        }   
    }

}

void keyReleased() {

  down=false;

}
void stop(){

  for (int i =0; i< 20;i++){

    sound[i].close();

  }

  minim.stop();

  super.stop();

}
////////////////////////////////right hand

void manouno() {

  port.write('E');

  delay(250);

  port.write('Q');

}
////////////////////////////////left hand

void manodos() {

  port.write('W');

  delay(250);

  port.write('Q');

}
void drawtrack(int t){
          pushMatrix();

            translate(width*0.5, height*0.5);

            rotate(ini[t]);
            noStroke();

            arc(0, 0,r[t],r[t],0,s[t]);

            ini[t] = ini[t] + s[t];
          popMatrix();
}
void deletetrack(){
   background(255);
}
void drawCirculo(float vel, float radio) {
  float angle = 0;
 for (int i = 0; i< 360; i++){
  float px = width/2 + cos(radians(angle))*(radio/2);

  float py = height/2 + sin(radians(angle))*(radio/2);
  noStroke();

  fill(0);

  ellipse (px, py, 5, 5);

  stroke(100);

  angle -= vel;
 }

// send small ellipse along sine curve // to illustrate relationship of circle to wave }


class playNote{

  AudioPlayer sound;
  playNote(AudioPlayer sound_){

    sound = sound_;
  }
  void playNote(){
    sound.play();
  }

}

class circular{

float radio, vel;

circular(float radio_, float vel_){
radio = radio_;
vel = vel_;

}

void drawCirculo(){

for (int u=0; u<360; u++){

float px = width/2 + cos(radians(u))*(radio/2);
float py = height/2 + sin(radians(u))*(radio/2);
fill(255);
ellipse (px, py, 1, 1);
stroke(255);
line(width/2, height/2, px, py);
stroke(200);
}
}

}