PROCESSING: SINE WAVE EXPERIMENTATION

In my experimentation, I utilized a sine wave code that allowed you to change parameters of the waves spread and intensity through changing values. The x spacing created a wider wave spread further along the x axis when increased in number. By adjusting the amplitude, the 'extremeness' of the slopes increased, showing a more seemingly intense response. I also adjusted the void setup, which is basically the window that displays the wave. I went with size (700,300) to hide the circles rising above the top-line. Adjusting angular velocity changes the physics of each balls drop, changing it from a gentle fall to a more intense "throw" to the ground. 




int xspacing = 16;   // How far apart should each horizontal location be spaced
int w;              // Width of entire wave

float theta = 0.0;  // Start angle at 0
float amplitude = 200.0;  // Height of wave
float period = 220.0;  // How many pixels before the wave repeats
float dx;  // Value for incrementing X, a function of period and xspacing
float[] yvalues;  // Using an array to store height values for the wave

void setup() {
  size(700, 300);
  w = width+16;
  dx = (TWO_PI / period) * xspacing;
  yvalues = new float[w/xspacing];
}

void draw() {
  background(0);
  calcWave();
  renderWave();
}

void calcWave() {
  // Increment theta (try different values for 'angular velocity' here
  theta += 0.05;

  // For every x value, calculate a y value with sine function
  float x = theta;
  for (int i = 0; i < yvalues.length; i++) {
    yvalues[i] = sin(x)*amplitude;
    x+=dx;
  }
}

void renderWave() {
  noStroke();
  fill(245);
  // A simple way to draw the wave with an ellipse at each location
  for (int x = 0; x < yvalues.length; x++) {
    ellipse(x*xspacing, height/8+yvalues[x], 16, 16);
  }
}

SPA - Knolling a Vizio Remote

Large Vibrating Mass

Altered Code:

int rad = 200;        // Width of the shape
float xpos, ypos;    // Starting position of shape 

float xspeed = 5;  // Speed of the shape
float yspeed = 5;  // Speed of the shape

int xdirection = 5;  // Left or Right
int ydirection = 5;  // Top to Bottom


void setup()
{
  size(640, 360);
  noStroke();
  frameRate(30);
  ellipseMode(RADIUS);
  // Set the starting position of the shape
  xpos = width/2;
  ypos = height/2;
}

void draw()
{
  background(102);

  // Update the position of the shape
  xpos = xpos + ( xspeed * xdirection );
  ypos = ypos + ( yspeed * ydirection );

  // Test to see if the shape exceeds the boundaries of the screen
  // If it does, reverse its direction by multiplying by -1
  if (xpos > width-rad || xpos < rad) {
    xdirection *= -1;
  }
  if (ypos > height-rad || ypos < rad) {
    ydirection *= -1;
  }

  // Draw the shape
  ellipse(xpos, ypos, rad, rad);
}



In this experiment, as I am fairly new to code, I focused on trying to understand how it works at a basic level. I started by altering the size of the shape as that was a variable that I was comfortable varying without (hopefully) breaking the code. As I played with size, I then began to change the speed to see what would be the craziest thing I could do within the code. This lead to me making the shape extremely large and moving fast (for its size) to the point where it just looks like its vibrating side to side.

Rotating Object

       Paper View       Plain Text View     

float a; // Angle of rotation
float offset = PI/180; // Angle offset between boxes
int num = 100; // Number of boxes

void setup() {
size(640, 360, P3D);
noStroke();
}

void draw() {

lights();

background(255, 200, 0);
translate(width/2, height/2);

for(int i = 0; i < num; i++) {
float gray = map(i, 0, num-1, 25, 150);
pushMatrix();
fill(gray);
rotateY(a + offset*i);
rotateX(a/2 + offset*i);
box(100);
popMatrix();
}

a += 0.05;
}

I adjusted the angle and speed of rotation, adding multiple boxes and adjusting the background to get a striking shape.

Caller I.D. Machine for Landlines

Caller I.D. Machine for Landlines

S— Buttons, input lines for phone cords
P—Processing Chip
A—LCD Screen, LED

SPA—Calculator

Raindrops on the moon

I started playing around with the background image example, I mainly changed the line moving down into multiple ellipses moving downwards, giving the impression of rain.

First, I defined three arrays for a certain amount of raindrops which store the speed, y and x coordinate of each raindrop. 

As part of the block of the setup function, I kept the background image of the space station on the moon and assigned a value to all elements of the arrays (using a for-loop), some of which are random (like speed and x coordinate), one is a constant (y coordinate, which I initialized to zero).

Within the draw function, I created another for-loop, in which the y coordinate is increased by the speed assigned to the individual raindrop in each repetition of the draw function.

To make the raindrops reappear once they reach the bottom edge of the picture, I introduced an if-clause (similar to the clause that was already there in the example) which resets the x value to a random value and the y value to zero.

Here is the original code:

/**

 * Background Image.

 *

 * This example presents the fastest way to load a background image

 * into Processing. To load an image as the background, it must be

 * the same width and height as the program.

 */

PImage bg;

int y;

void setup() {

  size(640, 360);

  // The background image must be the same size as the parameters

  // into the size() method. In this program, the size of the image

  // is 640 x 360 pixels.

  bg = loadImage("moonwalk.jpg");

}

void draw() {

  background(bg);

 

  stroke(226, 204, 0);

  line(0, y, width, y);

 

  y++;

  if (y > height) {

    y = 0;

  }

}

Here is my code:

/**

 * This is an example of a loop which produces multiple objects with random values on top of a background image.

 */

PImage bg;

int amountOfRaindrops = 10;

float[] speed = new float[amountOfRaindrops];

float[] x = new float[amountOfRaindrops];

float[] y = new float[amountOfRaindrops];

void setup() {

  size(640, 360);

  bg = loadImage("moonwalk.jpg");

 

  // initializes start values for raindrops

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

    // raindrops are colored with a shade of blue

    fill(0,0,random(255));

    speed[i]=random(10,20);

    x[i]=random(width);

    // y will change in draw function

    y[i]=0;

  }

}

void draw() {

  background(bg);

 

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

   // if statement resets raindrop to the top of the image if raindrop reached the bottom edge

     if (y[i]>height) {

        x[i]=random(width);

        y[i]=0;

     }

    

    // for each execution of the for loop, the speed will be added to the y position of each raindrop

    y[i] += speed[i];

   

    // a raindrop will be drawn with a hard coded size and changing x and y values.

    ellipse(x[i],y[i],20,30);

   }

}

Knolling an Electronic Drumset

Map no map

I opened the example file "Map", hoping to be able to do something with interactive maps like Google Maps. However, all I could do with the example to see an orange circle scale and fade as I move my cursor around. It wasn't the map I was looking for but still fun to explore what it can do. I made small changes to the code:
1) changed the canvas size
2) changed the movement variable from mouseX to mouseY
3) changed the color of the circle
4) change the position of the circle

void setup() {
  size(800, 600);
  noStroke();
}
// changed the canvas size
void draw() {
  background(0);
  // Scale the mouseX value from 0 to 640 to a range between 0 and 175
  float c = map(mouseY, 0, width, 0, 175);
  // changed from mouseX to mouseY. I want the shape to scale based on
  // the vertical movement of my cursor
  // Scale the mouseX value from 0 to 640 to a range between 40 and 300
  float d = map(mouseX, 0, width, 40, 300);
  fill(125, c, 100);
  // changed the color. exoeriment of RGB values and how it displays on screen
  ellipse(width/4, height/4, d, d); 
}
  // changed the position of the circle

Pulsating Recursion

For this assignment I modified the Recursion example, as shown below:

/**
 * Recursion.
 *
 * A demonstration of recursion, which means functions call themselves.
 * Notice how the drawCircle() function calls itself at the end of its block.
 * It continues to do this until the variable "level" is equal to 1.
 */

void setup() {
  size(640, 360);
  noStroke();
  noLoop();
}

void draw() {
  drawCircle(width/2, 280, 6);
}

void drawCircle(int x, int radius, int level) {                 
  float tt = 126 * level/4.0;
  fill(tt);
  ellipse(x, height/2, radius*2, radius*2);   
  if(level > 1) {
    level = level - 1;
    drawCircle(x - radius/2, radius/2, level);
    drawCircle(x + radius/2, radius/2, level);
  }
}


I liked the idea of recursion but I wanted to add some dynamic elements: Here's my final code:

/**
 * Pulsating Recursion.
 *
 */

int rspeed = 2;
int xspeed = 1;
int r;
int x;
int y = height/2;

void setup() {
  size(640, 360);
  noStroke();
}

void draw() {
  background(130);

  rspeed = changeSpeed(0,150,r, rspeed);
  xspeed = changeSpeed(-200,200,x,xspeed);

  r = r+rspeed;
  x = x+xspeed;

  drawCircle(width/2+x, r, 10,y);
}

int changeSpeed(int min, int max, int input, int inputSpeed){
  if(input > max || input < min){
    inputSpeed = inputSpeed*-1;
  }
  return inputSpeed;
}

void drawCircle(int x, float radius, int level,int y) {             
  float tt = 60 * level/4.0;
  fill(tt);
  ellipse(x, y+120, radius*2, radius*2);   
  if(level > 1) {
    level = level - 1;
    drawCircle(x, radius/1.2, level,y);
  }
}

To do this, I added a loop that incremented the radius and x-position of the recursive circles. To increment these values I created a function called changeSpeed that makes it easy to modify the dynamics of the pulsating circles. While the initial recursive pattern was cool, I modified it to be more simple, so that it acted like a pulse. To do this, I made all the circles concentric and added several more layers of recursion.

Knolling a Hairdryer

Knolling a Guitar Tuner

Horizontal Hues

This original code allows processing to generate a series of vertical rectangles depends on the width of the rectangle and the width of the screen. By tracking the change of X coordinate of the mouse, it generates new rectangles with different hues and then overlay on top of the older ones.

In my modified code,  I changed the background color from Black to white by alternating the RBG value. I  also modified the code to generate horizontal rectangles instead of vertical ones. Moreover, it now tracks the Y coordinate of the mouse and populates hue values base on that coordinate.

Modified Code: 

// Change from int barWidth to barHeigth, and change the int to a value that can be divided by the screen height. 
int barHeight = 72;
int lastBar = -1;

void setup()
{
  size(640, 360);
// change HSB ( Hue, Saturation, and Brightness) of the color now depending on canvas width
  colorMode(HSB, width, width, width); 
  noStroke();
// background color change from black to white 
  background(255);
}

void draw()
{
//change from mouseX to mouseY, now the int whichBar is depended on the Y coordinate of the mouse.
  int whichBar = mouseY / barHeight;
  if (whichBar != lastBar) {
    int barY = whichBar * barHeight;
// change fill mouseX to mouseY now the hue will depend on the Y coordinate of the mouse
    fill(mouseY, width, width);
//change the rects from vertical to horizontal  
    rect(0, barY, width, barHeight);
    lastBar = whichBar;
  }
}

Original Code: 

int barWidth = 20;

int lastBar = -1;

void setup() 

{

  size(640, 360);

  colorMode(HSB, height, height, height);  

  noStroke();

  background(0);

}

void draw() 

{

  int whichBar = mouseX / barWidth;

  if (whichBar != lastBar) {

    int barX = whichBar * barWidth;

    fill(mouseY, height, height);

    rect(barX, 0, barWidth, height);

    lastBar = whichBar;

  }

}

Rectangles and Vanishing Lines

Here is the original code:

size(640, 360);
background(0);

int gridSize = 40;

for (int x = gridSize; x <= width - gridSize; x += gridSize) {
  for (int y = gridSize; y <= height - gridSize; y += gridSize) {
    noStroke();
    fill(255);
    rect(x-1, y-1, 3, 3);
    stroke(255, 100);
    line(x, y, width/2, height/2);
  }
}

Here is my remixed code:

void setup(){
size(640, 360);
background(255);

int gridSize = 60;
int halfGrid = 30;
int fullGrid = 90;
}
void draw(){

 int gridSize = 60;
 int halfGrid = 30;
 int fullGrid = 90;

  background(0);
  rect(mouseX, mouseY, 15,15);
  line(mouseX + 15/2, mouseY + 15/2, width/2, height/2);

  for (int x = gridSize; x <= width - gridSize; x+= gridSize) {
  for (int y = gridSize; y <= height - gridSize; y += gridSize) {
    noStroke();
    fill(0,255,255);
    rect(x , y , 15, 15);
    stroke(255, 45, 10);
    line(x+15/2, y+15/2, width/2, height/2); 
  }
  }

//failed attempts at other experiments:
// here I was trying to add more rectangles in between the current animation that could shift together along x axis
  for (int x = fullGrid; x<= width + halfGrid ; x += gridSize) { //not sure why it stops making rectangles in the middle here
  for (int y = fullGrid; x<= height - fullGrid; x += gridSize){  // also not sure why it doesn't go down y axis here
    fill(255, 0, 0);
    rect(x, y, 20, 20);
 
  }
  }
}

What I changed:
I was able to change the colors, sizes, whereabouts, and strokes of the rectangles in the original code, as well as add my own rectangle attached to a line that would follow the mouse around. I tried and failed to add another section of rectangles (the red ones) that would appear in between the blue rectangles and be able to have all of them slide together along the x axis. However, I couldn't even get the rectangles to go across the whole width I wanted.