void setup() {
 // define the window size & enable anti-aliasing
 size(550, 800);
 background(255);
 smooth();
 noFill(); // not solid squares
 noLoop(); // only draw() once
}
 
void draw() {
 // allow for some padding around the edge
 translate(30,10);
 
 int x = 0, y = 0, side = 30;
 int i = 0;    // increment just like the original
 float j1, j2; // random numbers for translation and rotation
 
 for (int k = 0; k < 24; k++ ) { // iterate through y-axis
   for (int j = 0; j < 16; j++ ) { // iterate through x-axis
     i++;
     translate(x, y); // re-define coordinate axis to square
 
     // pick increasingly variable random numbers for
     j1 = random(-15*i/244,15*i/244); // translation
     j2 = random(-15*i/244,15*i/244); // & rotation
 
     // rotation should only affect one square at a time,
     //   so push and then pop that alteration to the coordinate axis
     pushMatrix();
     rotate(radians(j2));  // rotate the axis
     rect(j1, j1, 30, 30); // plot the square
     popMatrix(); // return the axis to its original state
 
     x=30; // x-position advances for each square drawn in row
     y=0;  // y-position shouldn't change in the middle of a row
   }
   x=-450; // return x to beginning of row position
   y=30;   // adjust y to next row
 }
}

//Samia Ahmed, samiaa@andrew.cmu.edu
//A reproduction of Schotter by Georg Nees
//Carnegie Mellon University: 51-482
//January 2011
 
  int rows = 23;
  int cols = 12;
  int side;
 
void setup(){
  size(392, 700);
  side = width/(cols+2);
  background(248, 244, 236);
  noLoop();
}
 
void draw(){
  for (int row = 0; row < rows; row++){
    for (int col = 0; col < cols; col++){
      pushMatrix();
      translate((side*col)+side/2+side, (side*row)+side/2+side); //resets the origin
      rotate(setRotation(row, col));
      noFill();
      rect(-(side/2)+setShift(row, col), -(side/2)+setShift(row, col), side, side);
      popMatrix();
    }
  }
 
}
 
float setRotation(int row, int col){
  float count = (row*cols+col);
  float rand = random(count);
  if (count > (rows*cols)/4 || random(rows*cols) < count)
    if (int(random(3)) == 1)
      return radians(90*(rand/(rows*cols)));
    else
     return -radians(90*(rand/(rows*cols)));
  return 0;
}
 
float setShift(int row, int col){
  float count = (row*cols+col);
  float rand = random(count);
  if(count > (rows*cols)/4 || random(row*col) < count)
     if (int(random(3)) == 1)
       return (side/2*(rand/(rows*cols)));
     else
       return -(side/2*(count/(rows*cols)));
  return 0;
}

/*
* Alex Wolfe - Spring 2011
* Interactive Art and Computational Design
* Reproducing Schotter(1965) by Georg Nees
*/
 
int rectSize = 20;
int rows = 23;
int col = 12;
int xOffset = 30;
int yOffset = 10;
int r = 8;
 
void setup(){
  size(300,500);
  background(255);
  rectMode(CORNER);
  smooth();
  noFill();
  stroke(0);
 
  for( int x=xOffset; x

// Constants
int MAX_DISPLACEMENT = 15;
int MAX_ROTATION = 45;
int MARGIN = 30;
 
// Processing Setup
void setup(){  
    smooth();
 
    size(240 + 2*MARGIN,440 + 2*MARGIN);
    background(255);
    noLoop();
    randomSeed(millis());
}
 
// Main drawing function
void draw(){     
    float rand_rot = 0.0;
    int rand_dis = 0;
    int r = 0, g = 0, b = 0;
 
    for (int j=0; j<22; j++){
 
	for (int i=0; i<12; i++){
 
	    // set up rotation and displacement
	    rand_rot = (random(-MAX_ROTATION,MAX_ROTATION))*j/22;
	    rand_dis = floor((random(-MAX_DISPLACEMENT,MAX_DISPLACEMENT))*j/22); 
 	    if ((i == 0 && rand_dis < 0) || (i == 11 && rand_dis > 0)){
		    rand_dis = -rand_dis;
	    }
 
	    // draw rectangle (col=i, row=j)
	    pushMatrix();
	    translate(MARGIN + 20*i + 10 + rand_dis, MARGIN + 20*j + 10 + rand_dis);
	    rotate(rand_rot*PI/180.0);
	    noFill();
            r = floor(random(50,255)*2/(22-j+1));
            g = floor(random(50,255)*2/(22-j+1));
            b = floor(random(50,255)*2/(22-j+1));
            stroke(r,g,b);
	    rect(-10, -10, 20, 20);
	    popMatrix();
 
	}
    }
}

 
//Samia Ahmed, samiaa@andrew.cmu.edu
//A reproduction of Text Rain by Camille Utterback
//Carnegie Mellon University: 51-482
//January 2011
 
import processing.video.*;
Capture capture;
char poem[][] = {{'I', ' ', 'l', 'i', 'k', 'e', ' ', 't', 'a', 'l', 'k', 'i', 'n', 'g', ' ', 'w', 'i', 't', 'h', ' ', 'y', 'o', 'u', ',' },
                 {'s', 'i', 'm', 'p', 'l', 'y', ' ', 't', 'h', 'a', 't', ':', ' ', 'c', 'o', 'n', 'v', 'e', 'r', 's', 'i', 'n', 'g', ',' }};
int poemLength = 24;
int position[][] = new int[2][poemLength];
int speed[][] = new int[2][poemLength];
color captureColor;
 
 
 
void setup() {
 
  size(640, 480);
  background(0, 0, 0);
  capture = new Capture(this, width, height, 30);
 
  //sets the speed at which the letters drop, and initial position
   for (int i = 0; i < 2; i++){
    for (int k = 0; k < poemLength; k++){
    speed[i][k] = int(random(4, 10));
    }
  }
 
}
 
void draw() {
 
  pushMatrix();
  scale(-1.0, 1.0);
  image(capture, -capture.width, 0);
  filter(GRAY);
  popMatrix();
 
  for (int i = 0; i < 2; i++){
    for (int k = 0; k < poemLength; k++){
      //these set when the red and blue texts are predominant
      if (i == 0 && (second() > 0 && second() < 35)){
      if(millis()%100 == 0)
        position[i][k] = -1000;
      }
      if (i == 1 && (second() > 30 || second() < 5)){
        if (millis()%100 == 0)
        position[i][k] = -1000;
      }
 
 
      captureColor = get(width/poemLength*k+(width/poemLength), position[i][k]+speed[i][k]);
      //moving the letters
      if (position[i][k] > height || random(1000) > 990) //out of bounds, and random deletion
        position[i][k] = -30;
      else if (position[i][k]+speed[i][k] >= height || position[i][k] < speed[i][k] || red(captureColor) > 100) //legal moves
        position[i][k] = position[i][k]+speed[i][k];
      else {
       while(red(get(width/poemLength*k+(width/poemLength), position[i][k]-speed[i][k])) < 100 && position[i][k] > 0) //jumping out of black
        position[i][k] = position[i][k]-speed[i][k];  
        }
 
 
      if (i == 0){
        fill(255, 0, 0);  
        text(poem[i][k], width/(poemLength+2)*k+width/poemLength*2.5, position[i][k]);
      }
      else if (i == 1){
        fill(0, 0, 255);
        text(poem[i][k], width/(poemLength+2)*k+width/poemLength, position[i][k]);
      }
    }
  }
 
}
 
void captureEvent(Capture capture) {
  capture.read();
}