Interactive Art and Computational Design, Spring 2012

I’m one of those guys who, upon hearing an awesome song played through my speakers, moves his face closer to the screen. I usually find myself doing it when I listen to songs on YouTube. While funny, this habit is not safe, and arguably unhealthy for my eyes. Thus with the help of Face OSC by Kyle McDonald and Dan Wilcox, I made a program that speeds up the rate of the video and thus the rate of the song if I get closer and slows down if I get too far away. Ultimately, this program was created to keep my eyes at a safe distance from my screen, but turned out to be a pretty fun program that explores the possibilities of face tracking technology.

[youtube https://www.youtube.com/watch?v=_hTIKV5uENU]

Comments Off

Deren Guler – FaceOSC

by deren @ 11:54 pm

I used applescript in Processing to control different application on my computer through face movements using the Cocoa library in Processing. I tried a few different applications but focused on Powerpoint because a friend of mine asked if I could hack Powerpoint to run through external gestures. I found an applescript handbook for Powerpoint 2004 which was compatible with my version of the program. The complete list of powerpoint commands can be found here
You can look up commands for most programs pretty easily and substitute different actions. I found that the mouth and eyebrow gestures were easiest to work with in terms of limiting the response rate to more dramatic gestures.

video coming…

Here is the code for Powerpoint 2004:

//
// a template for receiving face tracking osc messages from
// Kyle McDonald's FaceOSC https://github.com/kylemcdonald/ofxFaceTracker
//
// 2012 Dan Wilcox danomatika.com
// for the IACD Spring 2012 class at the CMU School of Art
//
// adapted from from Greg Borenstein's 2011 example
// http://www.gregborenstein.com/
// https://gist.github.com/1603230
//
import com.apple.cocoa.foundation.*; // to access applescript
import oscP5.*;
OscP5 oscP5;
 
// num faces found
int found;
 
// pose
float poseScale;
PVector posePosition = new PVector();
PVector poseOrientation = new PVector();
 
// gesture
float mouthHeight;
float mouthWidth;
float eyeLeft;
float eyeRight;
float eyebrowLeft;
float eyebrowRight;
float jaw;
float nostrils;
 
void setup() {
size(640, 480);
frameRate(30);
 
oscP5 = new OscP5(this, 8338);
oscP5.plug(this, "found", "/found");
oscP5.plug(this, "poseScale", "/pose/scale");
oscP5.plug(this, "posePosition", "/pose/position");
oscP5.plug(this, "poseOrientation", "/pose/orientation");
oscP5.plug(this, "mouthWidthReceived", "/gesture/mouth/width");
oscP5.plug(this, "mouthHeightReceived", "/gesture/mouth/height");
oscP5.plug(this, "eyeLeftReceived", "/gesture/eye/left");
oscP5.plug(this, "eyeRightReceived", "/gesture/eye/right");
oscP5.plug(this, "eyebrowLeftReceived", "/gesture/eyebrow/left");
oscP5.plug(this, "eyebrowRightReceived", "/gesture/eyebrow/right");
oscP5.plug(this, "jawReceived", "/gesture/jaw");
oscP5.plug(this, "nostrilsReceived", "/gesture/nostrils");
}
 
void draw() {
background(255);
stroke(0);
 
if(found &gt; 0) {
translate(posePosition.x, posePosition.y);
scale(poseScale);
noFill();
ellipse(-20, eyeLeft * -9, 20, 7);
ellipse(20, eyeRight * -9, 20, 7);
ellipse(0, 20, mouthWidth* 3, mouthHeight * 3);
ellipse(-5, nostrils * -1, 7, 3);
ellipse(5, nostrils * -1, 7, 3);
rectMode(CENTER);
fill(0);
rect(-20, eyebrowLeft * -5, 25, 5);
rect(20, eyebrowRight * -5, 25, 5);
}
 
//some powerpoint commands
if (mouthWidth &gt; 15){
String script = "tell application \"Microsoft PowerPoint\"" +"\n" + "go to next slide slideshow view of slide show window 1" + "\n" + "end tell";
executeScript(script);
}
 
if (mouthWidth &lt; 15){
String script = "tell application \"Microsoft PowerPoint\"" +"\n" + "go to previous slide slideshow view of slide show window 1" + "\n" + "end tell";
executeScript(script);
 
}
 
if (eyebrowLeft &gt; 8){
String script = "tell application \"Microsoft PowerPoint\"" +"\n" + "exit slide show slideshow view of slide show window 1 " + "\n" + "end tell";
executeScript(script);
}
 
if (eyebrowLeft &lt; 6){
String script = "set theView to slide show view of theWindow " + "\n" + "end tell";
executeScript(script);
}
 
}
 
void executeScript(String script) {
NSAppleScript myScript = new NSAppleScript(script);
NSMutableDictionary errors = new NSMutableDictionary();
myScript.execute(errors);
}
 
// OSC CALLBACK FUNCTIONS
 
public void found(int i) {
println("found: " + i);
found = i;
}
 
public void poseScale(float s) {
println("scale: " + s);
poseScale = s;
}
 
public void posePosition(float x, float y) {
println("pose position\tX: " + x + " Y: " + y );
posePosition.set(x, y, 0);
}
 
public void poseOrientation(float x, float y, float z) {
println("pose orientation\tX: " + x + " Y: " + y + " Z: " + z);
poseOrientation.set(x, y, z);
}
 
public void mouthWidthReceived(float w) {
println("mouth Width: " + w);
mouthWidth = w;
 
}
 
public void mouthHeightReceived(float h) {
println("mouth height: " + h);
mouthHeight = h;
}
 
public void eyeLeftReceived(float f) {
println("eye left: " + f);
eyeLeft = f;
}
 
public void eyeRightReceived(float f) {
println("eye right: " + f);
eyeRight = f;
}
 
public void eyebrowLeftReceived(float f) {
println("eyebrow left: " + f);
eyebrowLeft = f;
}
 
public void eyebrowRightReceived(float f) {
 
println("eyebrow right: " + f);
eyebrowRight = f;
}
 
public void jawReceived(float f) {
println("jaw: " + f);
jaw = f;
}
 
public void nostrilsReceived(float f) {
println("nostrils: " + f);
nostrils = f;
}
 
// all other OSC messages end up here
void oscEvent(OscMessage m) {
if(m.isPlugged() == false) {
println("UNPLUGGED: " + m);
}
}

Comments Off

MadelineGannon-3D Wolf Puppet with FaceOSC

by madeline @ 11:37 pm

3D Wolf Puppet

A framework for bringing 3D mesh data from Rhino (via Grasshopper) into Processing_0195.
The mesh from Rhino is exported as .txt files that contain the model’s UNIQUE VERTICES, as well as the ORDERED VERTICES needed to construct each face. .txt are then streamed from the Rhino/GH file into the sketch’s data folder.

This demo uses FaceOSC to control a 3D puppet, using eyebrow and mouth data to modify the ears and jaw. The code synchronizes the movements of your head, mouth, and eyebrows to control the expressions of a tessellated three-dimensional model. The model was first developed in Rhino3D, then translated to the Processing programming environment through Grasshopper, then connected to Kyle McDonald’s FaceOSC app through Oscp5. PeasyCam is also used for navigation.

Pivot points, as well as points to be rotated are specified in Grasshopper, then exported as .txt files to Processing. While the current puppet is highly tessellated, one can begin to create additional faces (and unique vertices) to give the model higher detail.

+ + + + + + + + + + + + + + + + + + +
Inspired by the work of Karolina Sobecka.
+ + + + + + + + + + + + + + + + + + +

Click to download the java project | gh2faceOSC (rhino + grasshopper files are in the data folder)

[vimeo https://vimeo.com/35550605]
**sorry about the weird faces**
____________________________________________________________________________________

Below is a screengrab of my Rhino / Grasshopper setup:

______________________________________________________________________________________

Comments Off

Kaushal Agrawal – FaceOSC

by kaushal @ 10:36 pm

[youtube=https://www.youtube.com/watch?v=30Szotjp8PA&feature=youtu.be]

I used the FaceOSC and OpenFrameworks wrapper to create a dummy Pacman game. The game is driven by mouth height and face orientation parameters returned by faceOSC. As soon as the user opens the mouth, the Pacman is set to move and when the user closes the mouth, Pacman moves forward. The user can only steer the Pacman left or right to the direction of movement by tilting the head in either directions. The tilt of the head is decided by threshold values to ensure correct turning of the character in the game. The original maze from Pacman was reduced to a simple one to reduce complexity and the ghosts were taken out. To make the game interesting, I added a level completion time. A few things that I realized after completing the project was that while its fascinating to see the game controlled by mouth, it can really exhaust you over multiple play session.
Interesting possibilities: Could use pre-recorded videos from interviews, and use that to drive the game and assign them Pacman scores!

Comments Off

Kaushal Agrawal 13-9-65

by kaushal @ 9:59 pm

//Number of rows and coloums in the patterns;
int pRow = 10; 
int pCol = 8;
int[][] pattern = new int[pRow][pCol];
int numXPoints,numYPoints;
PVector[][] gridPoints;
int initX, initY, aWidth, aHeight;
 
void setup(){
  size(600,650);
  background(255);
  smooth();
  numXPoints = pCol+1;
  numYPoints = pRow+1;
  initX = 50; initY = 50; aWidth=500; aHeight=500;
  gridPoints = new PVector[numYPoints][numXPoints];
  noFill();
  rect(initX,initY,aWidth,aHeight);  
 
   //Initialization
  gridPoints[0][0]=new PVector(initX,initY);
  int cellWidth = aWidth/pCol;
  int cellHeight= aHeight/pRow;
 
  //Determining the location of the points for the first row
  for(int j=1;j&lt;numXPoints-1;j++)
    gridPoints[0][j]=new PVector(gridPoints[0][j-1].x+random(cellWidth-(cellWidth/2),cellWidth+(cellWidth/2)),gridPoints[0][j-1].y);
  gridPoints[0][numXPoints-1]=new PVector(initX+aWidth, initY);
 
  //Getting the location of points for the entire Art
  for(int i=1;i&lt;numYPoints;i++){
    if(i==(numYPoints-1))
      gridPoints[i][0]=new PVector(gridPoints[i-1][0].x,initY+aHeight);
    else
      gridPoints[i][0]=new PVector(gridPoints[i-1][0].x,gridPoints[i-1][0].y+random(cellHeight-(cellHeight/4),cellHeight+(cellHeight/4)));
    for(int j=1;j&lt;numXPoints;j++){
 
      int deviation = (int)random(-10,10);
      gridPoints[i][j]=new PVector();
      gridPoints[i][j].x=gridPoints[i-1][j].x;
      if(i==(numYPoints-1))
        gridPoints[i][j].y=gridPoints[i][j-1].y;
      else
        gridPoints[i][j].y=gridPoints[i][j-1].y+deviation;
      line(gridPoints[i][j-1].x,gridPoints[i][j-1].y,gridPoints[i][j].x,gridPoints[i][j].y);
    }
  }
 
  for(int i=0;i&lt;pRow;i++){
    for(int j=0;j&lt;pCol;j++){
      pattern[i][j]=(int)random(0,3);
    }
  }
  noLoop(); 
}
 
 
void draw(){
  for(int m=0;m&lt;pCol;m++){
    int k = 0;
    while(k&lt;pRow){
      int choice = pattern[k][m];
      //LINES
      if(choice == 1){
        int numLines = (int)random(6,17);
        int temp=k;
        for(int l=0;l&lt;numLines;l++){
          float x = random(gridPoints[k+1][m].x, gridPoints[k+1][m+1].x);
          int z;
          for(z=k;z&lt;pRow;z++){
            if(pattern[z][m]==1){
              int i = z+1;
              int j = m+1;
 
              float m1 = (gridPoints[i-1][j].y - gridPoints[i-1][j-1].y)/(gridPoints[i-1][j].x - gridPoints[i-1][j-1].x);
              float m2 = (gridPoints[i][j].y - gridPoints[i][j-1].y)/(gridPoints[i][j].x - gridPoints[i][j-1].x);
              float y2 = m2*(x-gridPoints[i][j].x)+gridPoints[i][j].y;
              float y1 = m1*(x-gridPoints[i-1][j].x)+gridPoints[i-1][j].y;
              line(x,y1,x,y2);
            }
            else{
              temp = z;
              break;
            }
          }
          temp=z;
        }
        k=temp;
      }
 
      //TRIANGLES
      else if(choice == 2){
        int numTriangles = (int)random(5,13);
        for(int l=0;l0){
            float x = random(gridPoints[i-1][j-1].x, gridPoints[i-1][j].x);
            float y = m1*(x-gridPoints[i-1][j].x)+gridPoints[i-1][j].y;
            float x1 = random(gridPoints[i][j-1].x, gridPoints[i][j].x);
            float y1 = m2*(x1-gridPoints[i][j].x)+gridPoints[i][j].y;
            line(x,y,x1,y1);
            float x2 = random(gridPoints[i][j-1].x, gridPoints[i][j].x);
            float y2 = m2*(x2-gridPoints[i][j].x)+gridPoints[i][j].y;
            line(x,y,x2,y2);
          }
 
          //Triangles start from bottom to top
          else{
            float x =  random(gridPoints[i][j-1].x, gridPoints[i][j].x);
            float y = m2*(x-gridPoints[i][j].x)+gridPoints[i][j].y;
            float x1= random(gridPoints[i-1][j-1].x, gridPoints[i-1][j].x);
            float y1 = m1*(x1-gridPoints[i-1][j].x)+gridPoints[i-1][j].y;
            line(x,y,x1,y1);
            float x2= random(gridPoints[i-1][j-1].x, gridPoints[i-1][j].x);
            float y2 = m1*(x2-gridPoints[i-1][j].x)+gridPoints[i-1][j].y;
            line(x,y,x2,y2);
          }
        } 
        k++;
      }
 
      //BLANK
      else
        k++;
    }
  }
 
  //Draw Circles
  int numCircles = (int)random(8,10);
  for(int l=0;l&lt;numCircles;l++){
    float rad = random(5,70);
    float xc = random(initX+rad,(initX+aWidth-rad));
    float yc = random(initY+rad,(initY+aHeight-rad));
    ellipse(xc, yc, rad, rad);  
  }
}

Comments Off

MahvishNagda-13-9-65

by mahvish @ 7:53 pm

 
boolean getProbTrue(float prob){
  if (random(0, 1) &lt;= prob)
    return true; 
  else 
    return false; 
}
 
int getYatX(int x0, int y0, int x1, int y1, int x){
  return y0 + (((x-x0)*(y1-y0))/(x1-x0)); 
}
 
void setup(){
  size(500, 500); 
}
 
void draw(){
 
  // set up for each frame
  background(255); 
  strokeWeight(1); 
  stroke(0); 
 
  // border
  line(0, 0, 0, height); 
  line(width-1, 0, width-1, height); 
  line(0, 0, width, 0); 
  line(0, height-1, width, height-1);  
 
  float loRange = 0.8; 
  float hiRange = 1.2; 
 
  int[] Xs = new int[9];       // stores the X coordinates for grid
  int[][] Ys = new int[9][9];  // stores the Y coordinates for grid
 
  int[][] fills = new int[9][9]; 
 
  int avXi = width/(Xs.length-1);    // average for each X segment
  int avYi = height/(Ys.length-1);   // average for each Y segment
 
  // get the random X coordinates
  Xs[0] = 0; 
  Xs[Xs.length-1] = width; 
  for(int i=1; i &lt; Xs.length-1; i++){
      Xs[i] = Xs[i-1] + (int) random(loRange*avXi, hiRange*avXi); 
  }
 
  // get the random start Y coordinates
  for(int i=0; i &lt; Ys.length; i++){
    int interval = (int) random(loRange*avYi, hiRange*avYi); 
    if(i==0) 
      Ys[i][0] = interval; 
    else
      Ys[i][0] = Ys[i-1][0] + interval; 
  }
 
  // get all other coordinates
  for(int i=0; i &lt; Ys.length; i++){
    for(int j=1; j &lt; Ys[i].length; j++){
      Ys[i][j] = Ys[i][j-1] + (int) random((loRange-1)*avYi, (1-loRange)*avYi); 
    }
  }
 
  // now let&#039;s plot these
  for(int i=0; i &lt; Ys.length; i++){
    for(int j=1; j &lt; Ys[i].length; j++){
      line(Xs[j-1], Ys[i][j-1], Xs[j], Ys[i][j]); 
    }
  }
 
  // choose segment fills
  for(int i=0; i &lt; fills.length; i++){
    for(int j=0; j = 1 &amp;&amp; fills[i-1][j] != 1 &amp;&amp; 
		fills[i-1][j] != 3 &amp;&amp; getProbTrue(0.05)){
          fills[i][j] = 2; 
        } 
        // crossed lines filling 1 segment
        else if(getProbTrue(0.35)){
          fills[i][j] = 3; 
        }
      }
 
    }
  }
 
  // lets add vertical lines   
  for(int i=0; i &lt; Ys.length; i++){
    for(int j=1; j  0 &amp;&amp; fills[i][j] == 2){
        numSegments = 2; 
      }
 
      if(numSegments &gt; 0){
 
        // how many lines are we drawing 
        int numLines = (int) random(3, 15);
        if( fills[i][j] == 3) // just many more crossed lines 
           numLines *= 2; 
 
        for (int k=0; k  numSegments-1){ 
            Yks = getYatX( Xs[j-1], Ys[i-numSegments][j-1], 
				Xs[j], Ys[i-numSegments][j], Xk ); 
          }
 
          if(i &lt; Ys.length){
            Yke = getYatX( Xs[j-1], Ys[i][j-1], Xs[j], Ys[i][j], Xe ); 
          }
 
          line(Xk, Yks, Xe, Yke);         
        }
      }
    }
  }
 
  // draw circles 
  for(int i=0; i &lt; random(6,10); i++){
    int randX = (int) random(4, width); 
    int randY = (int) random(4, height); 
 
    int minofCorner = min(randX, randY); 
    minofCorner = min(minofCorner, width - randX); 
    minofCorner = min(minofCorner, height - randY); 
 
    int randRadius = (int) random(4, min(minofCorner, 80)); 
 
    noFill(); 
 
    ellipse(randX, randY, randRadius, randRadius); 
  }
 
  delay(1000); 
 
  if (keyPressed == true) {
    saveFrame(&quot;line-####.tif&quot;); 
  }
}

Comments Off

Rothera_alex-13-9-65

by alex @ 7:40 pm

ROTHERA_gaunlet1

///Alex Rothera 1/23/12
 
//Interactive Art and Computational Design
 
 
PVector v1, v2, v3, v4, v5, v6, v7;
 
void setup() {
  size(800, 800);
  smooth();
  background(255);
  frameRate(.2);
  stroke(0);
  strokeWeight(1.5);
}
 
void draw() {
  fill(255);
  rect(0, 0, width, height);
  noFill();
  rect(1, 1, width-3, height-3);
  int overallHorz = floor(random(5, 10));  // # overall divisions
  float horizSpacing = height/overallHorz;  //horizontal spacing distance
  int horizDivisions = 8;
 
 
  PVector [] [] gridXY = new PVector[horizDivisions] [overallHorz];  //2D array to hold ref. points
 
  ///GRID CREATION
  ///establish/store x and y
 
  for (int i=0; i&lt;overallHorz; i++) {
    for (int j=0; j&lt;horizDivisions; j++) {
 
      float tempY = (horizSpacing*i) + random(0, 40);
      float tempX;
 
      if (j==0)  
        tempX=0;
      else if (j==(horizDivisions-1))
        tempX=width;
      else {
        tempX = ((width/horizDivisions) * j) + random(-20, 20);
      }
 
      v1 = new PVector(tempX, tempY);
      gridXY [j][i] =  v1;
    }
  }
 
  /////// //drawing lines (from gridXY points)//////////
  for (int m=0; m&lt;overallHorz; m++) {
    for (int n=0; n&lt;horizDivisions-1; n++) {
 
      v2 = new PVector();
      v2 = gridXY[n][m];
 
      v3 = new PVector();
      v3 = gridXY[n+1][m];
 
      line(v2.x, v2.y, v3.x, v3.y);
    }
  }
 
///////// //***drawing zigzags + straights  ***//////////////
 
  for (int y=0; y&lt;overallHorz-1; y++) {       //for EVERY SECTOR
    for (int z=0; z&lt;horizDivisions-1; z++) {
 
      v4 = new PVector(); 
      v5 = new PVector(); 
      v6 = new PVector(); 
      v7 = new PVector();
      v4 = gridXY[z][y];
      v5 = gridXY[z+1][y];
 
      v6 = gridXY[z][y+1];
      v7 = gridXY[z+1][y+1];
 
      float topSLOPE = (v4.y-v5.y)/(v4.x-v5.x);
      float bottomSLOPE = (v6.y-v7.y)/(v6.x-v7.x);
      //mx+b = y;
      float b1 = v4.y - (topSLOPE*v4.x);
      float b2 = v6.y - (bottomSLOPE*v6.x);
 
 
    //////choosing zigzags, straights, or none
      int decision = floor(random(0, 5));  
      //#0
      //*zig zags*// 
      if (decision == 0) {  
        float numSlashes = random(8, 30);
        for (int g=0; g&lt;numSlashes; g++) {
          float newX = (random(v4.x, v5.x));
          float newX2 = (random(v6.x, v7.x));
          float newY = (topSLOPE*newX) + b1;
          float newY2 = (bottomSLOPE*newX2) + b2;
 
          line(newX, newY, newX2, newY2);
        }
      }
      //#1
      //*straight lines*//
      else if (decision == 1) {
        float numLines = random(5, 18);
        for (int h=0; h&lt;numLines; h++) {
          float newX = (random(v4.x, v5.x));
          float newY = (topSLOPE*newX) + b1;
          float newY2 = (bottomSLOPE*newX) + b2;
 
          line(newX, newY, newX, newY2);
        }
      }
 
      //#2
      //*blank area*//
      else {
        //println(&quot;*skip*&quot;);
      }
    }
  }
 
  /******/  ////CIRCLES////////********///   
 
  int randCircles = floor(random(3, 11));
 
  for (int q=0; q&lt;randCircles; q++) {
    float randRadius = random(2, 150);
    ellipse(random(0, width), random(0, height), randRadius, randRadius);
  }
}

Comments Off

KelseyLee-FaceOSC

by kelsey @ 3:51 am

Using FaceOSC and Processing I wanted to create an interactive visualization showing the person’s movement about the frame. The Processing file parses the data from FaceOSC and focuses in on the mouth height and eyebrow/eye heights. When the mouth is open past a certain threshold, stars are generated on the canvas. Meanwhile, raising the eyebrows will change the color of the stars that are to be generated next. Scale is also taken into account, with the person being closer to the screen resulting in larger stars.

The circle on the canvas indicates where the stars will originate, and maps to the person’s nose position. Each star has a designated “life”, so that eventually they will dissipate, allowing screen space to be freed up, however until then they will bounce about the screen, rebounding off the bounds of the frame.

[youtube=https://www.youtube.com/watch?v=TajOcZieAwI&feature=youtu.be]

In version 2, I instead had a background fill that was partially transparent, allowing the stars’ trails to be evident however, eventually fading out after many semi-opaque layers pile up.

[youtube=https://www.youtube.com/watch?v=YtHuzdiL0dI&feature=youtu.be]

Comments Off

SankalpBhatnagar-13-9-65

by sankalp @ 3:46 am

Hello, this is Part 2 of my Project 1 (Guantlet) where I was to reproduce the 1965 Plotter work, 13/9/65 Nr.2, by Frieder Nake in my own preferred programming enviornment. I chose Processing. Striving for an accurate reproduction definitely took me quite a while. Enjoy!

You can take a look at my code below:

void setup()
{
  size(899,935);
  background(255,255,255);
background(255,255,255);
  smooth();
  noFill();
  strokeWeight(2);
}
 
void draw()
{
 
  smooth();
  background(255,255,255);
  drawInitialSquare();
  drawCircles();
 
  //ALL Horizontal Lines
  drawHorizontalLine(20,60,184,43,557,38,620,45,822,24,880,21,880,21,880,21); //first line
  drawHorizontalLine(20,184,191,186,341,200,421,196,585,207,687,178,881,174, 881,174); //second line
  drawHorizontalLine(21,274,184,255,345,266,423,253,584,249,632,262,880,261,880,261); //third line
  drawHorizontalLine(20,349,244,345,436,339,586,323,627,336,690,330,830,340,882,348); //fourth line
  drawHorizontalLine(20,394,186,394,345,379,586,385,629,374,696,378,836,363,881,353); //fifth line
  drawHorizontalLine(20,517,186,516,344,498,426,481,584,478,633,460,689,448,882,450); //sixth line
  drawHorizontalLine(21,575,335,569,426,571,584,564,633,557,688,560,828,545,881,555); //seventh line
  drawHorizontalLine(22,674,204,666,422,657,585,633,628,629,693,627,830,640,882,630); //eighth line
  drawHorizontalLine(23,761,184,753,344,739,426,733,586,742,693,730,823,737,882,734); //ninth line
 
  //ALL Diagonal Clusters
  drawDiagonalsBetween(10,448,16,568,16,448,40,568,39); //between top and first left to right
 
  drawDiagonalsBetween(20,20,60,184,43,20,184,191,186); //between first and second left to right
  drawDiagonalsBetween(10,437,40,579,39,447,197,526,203);
  drawDiagonalsBetween(10, 587, 43, 629, 45, 587, 207, 622, 196);
  drawDiagonalsBetween(20,691,40,880,21,691,178,881,174);
 
  drawDiagonalsBetween(17,587,207,627,197,587,251,627,261); //between second and third left to right
  drawDiagonalsBetween(20,699,178,881,174,699,262,881,261);
 
  drawDiagonalsBetween(30,20,275,181,257,20,348,175,345); //between the third and fourth left to right
  drawDiagonalsBetween(15, 343,267,420,255,343,342,425,339);
  drawDiagonalsBetween(15,468,254,583,249,477,335,576,323);
  drawDiagonalsBetween(30,629,262,688,262,629,336,688,330);
  drawDiagonalsBetween(10,693,263,810,261,715,332,794,338);
 
  drawDiagonalsBetween(20,20,350,170,348,20,394,182,394); //between the fourth and fifth left to right
  drawDiagonalsBetween(20,343,343,420,341,342,378,427,381);
 
  drawDiagonalsBetween(10,346,380,392,381,349,495,426,479);//between the fifth and sixth left to right
  drawDiagonalsBetween(10,630,375,688,379,630,459,688,449);
  drawDiagonalsBetween(20,697,380,827,365,693,448,820,448);
 
  drawDiagonalsBetween(10,195,515,339,500,201,572,338,568);//between the sixth and seventh left to right
  drawDiagonalsBetween(10,349,497,423,482,360,569,421,569);
  drawDiagonalsBetween(20,587,478,629,463,590,563,629,558);
 
  drawDiagonalsBetween(15,21,575,174,573,21,674,130,669);//between the seventh and eigth left to right
  drawDiagonalsBetween(15,337,569,426,572,338,660,427,656);
  drawDiagonalsBetween(20,631,558,693,562,630,628,693,627);
 
  drawDiagonalsBetween(10,235,665,337,661,195,753,329,741);//between the eigth and ninth left to right
  drawDiagonalsBetween(10,453,654,576,634,436,733,582,742);
 
  drawDiagonalsBetween(20,719,733,826,739,701,878,828,876); //between the ninth and bottom
 
  //ALL Vertical Clusters
  drawVerticalsBetween(10,655,42,684,40, 655,262,684,262);  //between first and third lines left to right
 
  drawVerticalsBetween(15,341,200,421,196,341,266,421,253); //between second and third lines left to right
  drawVerticalsBetween(20,20,184,164,186,20,274,164,258);
  drawVerticalsBetween(15,530,204,555,206,530,250,555,249);
 
  drawVerticalsBetween(10,594,326,623,335,494,410,623,374); //between fourth and fifth left to right
  drawVerticalsBetween(20,709,332,828,341,709,376,828,365);
 
  drawVerticalsBetween(30,444,339,532,329,444,479,532,479); //between fourth and sixth left to right
 
  drawVerticalsBetween(10,186,395,229,391,186,514,229,510); //between fifth and sixth left to right
  drawVerticalsBetween(20,256,388,334,381,258,506,334,499);
 
  drawVerticalsBetween(30,834,365,882,353,834,546,882,556);//between fifth and seventh left to right
 
  drawVerticalsBetween(20,201,573,305,571,201,665,305,661); //between seventh and eigth left to right
  drawVerticalsBetween(30,336,570,425,571,336,660,425,657);
  drawVerticalsBetween(30,438,572,579,566,438,654,579,633);
 
  drawVerticalsBetween(15,341,660,427,656,341,738,427,732); //between eigth and ninth left to right
  drawVerticalsBetween(30,704,628,811,639,704,730,811,736);
  drawVerticalsBetween(20,831,640, 882,631,831,735,882,733);
 
  drawVerticalsBetween(10,586,633,628,630,586,877,633,877); //between eighth and bottom left to right
 
  noLoop();
  println("Finished.");
  exit();
}
 
//initial square
void drawInitialSquare()
{
  line(20,20,880,13);
  line(20,20,23,882);
  line(23,882,883,876);
  line(883,876,880,13);
}
 
void drawHorizontalLine(int a, int A, int b, int B, int c, int C, int d, int D, int e, int E, int f, int F, int g, int G, int h, int H)
{
  line(a,A,b,B);
  line(b,B,c,C);
  line(c,C,d,D);
  line(d,D,e,E);
  line(e,E,f,F);
  line(f,F,g,G);
  line(g,G,h,H);
}
 
void drawVerticalsBetween(float n,float a, float A, float b, float B, float c, float C, float d, float D)
{
  for(float i=a; i&lt;b ; i=i+random(1,n))
  {
    float temp1= findY(i,a,A,b,B);
    float temp2= findY(i,c,C,d,D);
    line(i,temp1,i,temp2);
  }
 
}
 
void drawDiagonalsBetween(float n, float a, float A, float b, float B, float c, float C, float d, float D)
{
  for (int i = 0; i &lt; n; i++)
  {
    float x1 = random(a,b);
    float x2 = random(c,d);
    float y1 = findY(x1,a,A,b,B);
    float y2 = findY(x2,c,C,d,D);
    line(x1,y1,x2,y2);
  }
}
 
float findY(float X, float xi, float yi, float xf, float yf)
{
  float s= (yf-yi)/(xf-xi);
  float Y= s*(X-xi)+yi;
  return(Y);
}
 
void drawCircles()
{
  ellipse(69,59.5,39,39);
  ellipse(839,81,66,66);
  ellipse(232,237,83,83);
  ellipse(269,422,44,44);
  ellipse(376,435,128,128);
  ellipse(26,477,6,6);
  ellipse(236,663,131,131);
  ellipse(328,734,42,42);
}

Comments Off

« Previous Page — Next Page »

Sam Lavery – 13-9-65

SankalpBhatnagar-FaceOSC

Deren Guler – FaceOSC

MadelineGannon-3D Wolf Puppet with FaceOSC

Kaushal Agrawal – FaceOSC

Kaushal Agrawal 13-9-65

MahvishNagda-13-9-65

Rothera_alex-13-9-65

KelseyLee-FaceOSC

SankalpBhatnagar-13-9-65