Robert Oh- Project 11- Composition

version2

//Robert Oh
//Section C
//rhoh@andrew.cmu.edu
//Project-11-Composition

var turtle;
var fx = 240;
var fy = 240;
var diffX = 100;
var diffY = 100;

function setup() {
    createCanvas(480, 480);
    frameRate(30);
    noStroke();
}
 
function draw() {
    background(130, 255, 246);
    fishDisplay(fx, fy);

    diffX = mouseX - fx;
    diffY = mouseY - fy;

    if (diffX > 1 || diffX < -1){
        fx = fx + (diffX)/30;
    }
    
    if (diffY > 1 || diffY < -1){
        fy = fy + (diffY)/30
    }
}

// drawing each fish
function fishDisplay(x, y) {
    turtle = makeTurtle(x, y);
    turtle.penDown();
    turtle.face(270);
    turtle.setColor(100);
    turtle.setWeight(3);

    //body
    for (var i = 0; i < 360; i ++){
    turtle.forward(.7);
    turtle.right(1);
    }

    turtle.face(0);
    turtle.penUp();
    turtle.forward(80);

    //tail
    turtle.penDown();
    turtle.face(30);
    turtle.forward(40);
    turtle.face(270);
    turtle.forward(40);
    turtle.face(150);
    turtle.forward(40);

    turtle.penUp()
    turtle.face(180);
    turtle.forward(60);
    turtle.face(270);
    turtle.forward(25);

    //eye
    turtle.penDown();
    turtle.face(0);
    for (var i = 0; i < 180; i ++){
        turtle.forward(.2);
        turtle.right(2);
    }
}

function turtleLeft(d){this.angle-=d;}function turtleRight(d){this.angle+=d;}
function turtleForward(p){var rad=radians(this.angle);var newx=this.x+cos(rad)*p;
var newy=this.y+sin(rad)*p;this.goto(newx,newy);}function turtleBack(p){
this.forward(-p);}function turtlePenDown(){this.penIsDown=true;}
function turtlePenUp(){this.penIsDown = false;}function turtleGoTo(x,y){
if(this.penIsDown){stroke(this.color);strokeWeight(this.weight);
line(this.x,this.y,x,y);}this.x = x;this.y = y;}function turtleDistTo(x,y){
return sqrt(sq(this.x-x)+sq(this.y-y));}function turtleAngleTo(x,y){
var absAngle=degrees(atan2(y-this.y,x-this.x));
var angle=((absAngle-this.angle)+360)%360.0;return angle;}
function turtleTurnToward(x,y,d){var angle = this.angleTo(x,y);if(angle< 180){
this.angle+=d;}else{this.angle-=d;}}function turtleSetColor(c){this.color=c;}
function turtleSetWeight(w){this.weight=w;}function turtleFace(angle){
this.angle = angle;}function makeTurtle(tx,ty){var turtle={x:tx,y:ty,
angle:0.0,penIsDown:true,color:color(128),weight:1,left:turtleLeft,
right:turtleRight,forward:turtleForward, back:turtleBack,penDown:turtlePenDown,
penUp:turtlePenUp,goto:turtleGoTo, angleto:turtleAngleTo,
turnToward:turtleTurnToward,distanceTo:turtleDistTo, angleTo:turtleAngleTo,
setColor:turtleSetColor, setWeight:turtleSetWeight,face:turtleFace};
return turtle;}

For this project, I went back to data exam 1 once again and borrowed the fish design we had drawn. I wanted to revisit the data exam and had the fish follow the mouse cursor. Overall, I had a lot of fun recreating the fish (but with turtle-style drawing).

 

Robert Oh- Looking Outwards- 11

Caption: “Star Wars- Imperial March on Eight Floppy Drives”

For this week’s looking outwards post, I decided to talk about this interesting YouTube video made by user MrSolidSnake745 (whose YouTube channel contains other technology-based music). I really admire this project because the whole set-up is very unique. Using 8 different floppy drives to alternate between tones and pitches to create a universally famous theme is a cool idea!

I have no idea how the creator actually got to create this music, but if I had to guess, the creator probably set up each individual floppy drive to play a certain tone and timed each floppy drive perfectly to play the “Imperial March” theme perfectly. All in all, I thought this was a very cool project!

Hannah Cai—Project 11—Composition

click to generate a new tree!

/* Hannah Cai
Section C
hycai@andrew.cmu.edu
Project-11-Composition
*/

//turtle code
function turtleLeft(d) {
    this.angle -= d;
}
function turtleRight(d) {
    this.angle += d;
}
function turtleForward(p) {
    var rad = radians(this.angle);
    var newx = this.x + cos(rad) * p;
    var newy = this.y + sin(rad) * p;
    this.goto(newx, newy);
}
function turtleBack(p) {
    this.forward(-p);
}
function turtlePenDown() {
    this.penIsDown = true;
}
function turtlePenUp() {
    this.penIsDown = false;
}
function turtleGoTo(x, y) {
    if (this.penIsDown) {
      stroke(this.color);
      strokeWeight(this.weight);
      line(this.x, this.y, x, y);
    }
    this.x = x;
    this.y = y;
}
function turtleDistTo(x, y) {
    return sqrt(sq(this.x - x) + sq(this.y - y));
}
function turtleAngleTo(x, y) {
    var absAngle = degrees(atan2(y - this.y, x - this.x));
    var angle = ((absAngle - this.angle) + 360) % 360.0;
    return angle;
}
function turtleTurnToward(x, y, d) {
    var angle = this.angleTo(x, y);
    if (angle < 180) {
        this.angle += d;
    } else {
        this.angle -= d;
    }
}
function turtleSetColor(c) {
    this.color = c;
}
function turtleSetWeight(w) {
    this.weight = w;
}
function turtleFace(angle) {
    this.angle = angle;
}
function makeTurtle(tx, ty) {
    var turtle = {x: tx, y: ty,
                  angle: 0.0, 
                  penIsDown: true,
                  color: color(0),
                  weight: strokeWeight(w),
                  left: turtleLeft, right: turtleRight,
                  forward: turtleForward, back: turtleBack,
                  penDown: turtlePenDown, penUp: turtlePenUp,
                  goto: turtleGoTo, angleto: turtleAngleTo,
                  turnToward: turtleTurnToward,
                  distanceTo: turtleDistTo, angleTo: turtleAngleTo,
                  setColor: turtleSetColor, setWeight: turtleSetWeight,
                  face: turtleFace};
    return turtle;
}

/////my code

var angle;
var x;
var y;
var w = 5;
var minAngle = 1;
var maxAngle = 30;
var minRatio = .6;
var maxRatio = .9;

function setup() {
    createCanvas(480, 480);
    background(250);
    strokeJoin(MITER);
    strokeCap(PROJECT);
    frameRate(1);
}

function tree(length, turtle, w, r, l) {
  if (length > 10) { //create recursive branches
    ratio = random(minRatio, maxRatio)
    turtle.forward(length);
    turtle.setWeight(w * ratio)
    turtle.right(r);
    tree(length * ratio, turtle, w*ratio, random(minAngle,maxAngle), random(minAngle, maxAngle));
    turtle.left(r+l);
    tree(length * ratio, turtle, w*ratio, random(minAngle, maxAngle), random(minAngle, maxAngle));
    turtle.right(l);
    turtle.setWeight(w / ratio)
    turtle.back(length);
  } else { //draw flowers!
    turtle.setColor("Pink");
    turtle.setWeight(10);
    turtle.forward(10);
    turtle.setColor(0);
    turtle.setWeight(w);
    turtle.back(10);
  }
  noLoop();
}

function draw() {
    var turtle = makeTurtle(width / 2, height);
    //trunk
    turtle.penDown();
    turtle.right(270);
    turtle.forward(length);
    //branches
    tree(100, turtle, w, random(minAngle,maxAngle), random(minAngle,maxAngle))
}

//refresh the canvas when mouse is clicked
function mouseClicked() {
  setup();
  draw();
}

For this project, I was inspired by recursive trees, and I wanted to see if I could make one with turtle. Although it took a long time to figure out, I’m really proud of the end result! In the future, I’d want to try and animate the tree or make it interactive, although it might turn out to be too computationally expensive. Overall, I feel like I learned a lot about turtles and recursive functions, and I had a lot of fun!

Joanne Lee – Looking Outward 11

Alan Walker’s 2015 hit single, ‘Faded’.

When I realized this week’s theme was computational music, I immediately thought of Alan Walker specifically. He is a music producer and he creates his music (EDM type of music) using a computer program that allows him to combine synthetic instruments and sounds. He is also able to edit the sound waves in the program to tweak it any which way he wants and add effects such as echo or reverb to name a few. The song that I chose specifically is ‘Faded’ which is one of his most popular songs. When I first came across this song, it really piqued my interest in computer music and I actually felt motivated to learn about computer music.

Walker obviously begins with an artistic vision and then he tinkers with the program to make sure every beat and sound is placed exactly where he wants it to be. Provided below is a video of one of this studio sessions and he has other studio sessions on his channel. I am thankful to live in a generation where computer music allows someone to create music with all sorts of synthetic instruments on their own from the comforts of their own home / studio!

 

Alan Walker in his studio session for ‘Faded’, showing snippets of the thought process behind his hit song.

Sophie Chen – Looking Outwards 11

Laetitia Sonami

Laetitia Sonami is a sound artist, performer, and composer of interactive electronic music based in San Francisco. What initially drew my attention is “The Lady’s Glove”, an instrument she developed herself, which triggers and manipulates sound in live performance. This instrument is worn on her right hand, and is a black glove made of mesh integrated with a lot of different sensors such as micro-switches, pressure pads, ultrasonic receivers, and light sensors, just to name a few. The signals the glove receive are connected to a hardware named Sensorlab, which is then mapped onto MAX MSP running on a computer, which connects it to pre-stored sounds.

Sonami performing in her glove instrument

Sonami said that through creating this instrument, she was trying to figure out at which point does a controller become an instrument. I found what she said to be very insightful and thought provoking, especially applicable today when there are so many tools around us that we can just use to generate things without even putting much thought into it. Sonami concludes that when a software starts adapting to the controller, it becomes more of a symbiosis between the controller, the code, and the software. I think her glove does successfully embody that and qualify as an instrument, not just a controller/generator.

(jump to 10:34 for Sonami performing with the glove)

Alexandra Kaplan – Looking Outwards – 11

 

Video of the project

A computational musician I found to be interesting is Mari Kimura, a violinist. The project I am focusing on is Bebe, a project made performed by violin and computer. The piece was originally written in 2008, with edits made to it in 2012. From Kimura’s description of the project, it seems she used the Max computer program to play music along with her. What caught my eye (or should I say ear) is how she created the program to follow along with her in order to let her improvise. From her comments, it seems that many computer music projects she has previously worked on put the musician in a place in which they had to play exactly to the note to keep up with the computer. I think it is amazing what she accomplished and what technology can do to improvise and keep in harmony with brilliant musicians.

Sophia Kim – Project 11 – Sec C

sketch

// Sophia S Kim
// Section C 1:30
// sophiaki@andrew.cmu.edu 
// Project-11-Turtle Freestyle

var strOpt = 1; 
var turtle1;
var turtle2;

function setup() {
  createCanvas(480, 400);
}
 
function draw() {
  background(175);
  if (strOpt === 1) {
    orangeLines();
  }
  if (strOpt === 2) {
    redLines();
  }
  if (strOpt === 3) {
    greenLines();
  }
  if (strOpt === 4) {
    purpleLines(); 
  }
}

//function for line 1 - longest line  
function line1(x, y, z){
  turtle1 = makeTurtle(x, y); 
  turtle1.setWeight(10); 
  turtle1.setColor(z);

  turtle1.right(30);
  turtle1.penDown();
  for (i = 0; i < 6; i++) {
    turtle1.forward(15);
    turtle1.right(50);
    turtle1.forward(15);
    turtle1.left(50);
  }
  turtle1.penUp();
}

//function for line 2 
function line2(a, b, n) {
  turtle2 = makeTurtle(a, b); 
  turtle2.setWeight(10); 
  turtle2.setColor(n);

  turtle2.left(30);
  turtle2.penDown();
  for (i = 0; i < 3; i++) {
    turtle2.forward(15);
    turtle2.left(50);
    turtle2.forward(15);
    turtle2.right(50);
  }
  turtle2.penUp();
}

//function for line 3 
function line3(j, k, f) {
  turtle3 = makeTurtle(j, k); 
  turtle3.setWeight(10); 
  turtle3.setColor(f);

  turtle3.right(50);
  turtle3.penDown();
  for (i = 0; i < 4; i++) {
    turtle3.forward(15);
    turtle3.right(50);
    turtle3.forward(15);
    turtle3.left(50);
  }
  turtle3.penUp();
}

//function for line 4 
function line4(l, m, p) {
  turtle4 = makeTurtle(l, m); 
  turtle4.setWeight(10); 
  turtle4.setColor(p);

  turtle4.right(-50);
  turtle4.penDown();
  for (i = 0; i < 4; i++) {
    turtle4.forward(15);
    turtle4.right(50);
    turtle4.forward(15);
    turtle4.left(50);
  }
  turtle4.penUp();
}

//function for line 5 
function line5(o, h, q) {
  turtle5 = makeTurtle(o, h); 
  turtle5.setWeight(10); 
  turtle5.setColor(q);

  turtle5.right(-80);
  turtle5.penDown();
  for (i = 0; i < 5; i++) {
    turtle5.forward(15);
    turtle5.right(50);
    turtle5.forward(15);
    turtle5.left(50);
  }
  turtle5.penUp();
}
//draws white lines, pink shapes, and green block in background
function orangeLines() {
  //makes the green block of color in background
  fill("GREEN");
  noStroke();
  beginShape();
  vertex(0, 150);
  vertex(480,75);
  vertex(480, 400);
  vertex(0, 400); 
  endShape(CLOSE);
  //line color orange
  line1(350, 30, "ORANGE"); 
  line2(50, 330, "ORANGE");
  line3(370, 270, "ORANGE");
  line4(50, 100, "ORANGE");
  line5(190, 190, "ORANGE");

}

//draws pink lines, white shapes, and blue block in background
function redLines() {
  //makes the blue block in background
  fill("BLUE");
  noStroke();
  beginShape();
  vertex(0, 140);
  vertex(480, 200);
  vertex(480, 400);
  vertex(0, 400); 
  endShape(CLOSE);

  //line color red 
  line1(20, 240, "RED");
  line2(250, 90, "RED");
  line3(100, 90, "RED");
  line4(340, 360, "RED");
  line5(300, 270, "RED");
}

//draws green lines, yellow shapes, and pink block in background 
function greenLines() {
  //makes pink block in background
  fill(255, 125, 125);
  noStroke();
  beginShape();
  vertex(0, 150);
  vertex(420, 0);
  vertex(480, 0);
  vertex(480, 400);
  vertex(0, 400); 
  endShape(CLOSE);

  //draw green line 
  line1(60, 250, "GREEN");
  line2(370, 350, "GREEN");
  line3(390, 50, "GREEN");
  line4(50, 90, "GREEN");
  line5(220, 250, "GREEN");
}

//draws orange lines, blue shapes, and yellow block in background
function purpleLines() {
  //makes orange block in background
  fill("GOLDENROD");
  noStroke();
  beginShape();
  vertex(0, 0);
  vertex(100, 0);
  vertex(480, 300);
  vertex(480, 480); 
  vertex(0, 480);
  endShape(CLOSE);

  //draws purple line
  line1(350, 50, "PURPLE");
  line2(120, 90, "PURPLE");
  line3(90, 190, "PURPLE");
  line4(350, 380, "PURPLE");
  line5(220, 200, "PURPLE");
}

function mousePressed() {
  strOpt ++; // mouse is pressed every time changes the lines & line colors
  if (strOpt > 4) {
    strOpt = 1; 
  }
}


function turtleLeft(d){this.angle-=d;}function turtleRight(d){this.angle+=d;}
function turtleForward(p){var rad=radians(this.angle);var newx=this.x+cos(rad)*p;
var newy=this.y+sin(rad)*p;this.goto(newx,newy);}function turtleBack(p){
this.forward(-p);}function turtlePenDown(){this.penIsDown=true;}
function turtlePenUp(){this.penIsDown = false;}function turtleGoTo(x,y){
if(this.penIsDown){stroke(this.color);strokeWeight(this.weight);
line(this.x,this.y,x,y);}this.x = x;this.y = y;}function turtleDistTo(x,y){
return sqrt(sq(this.x-x)+sq(this.y-y));}function turtleAngleTo(x,y){
var absAngle=degrees(atan2(y-this.y,x-this.x));
var angle=((absAngle-this.angle)+360)%360.0;return angle;}
function turtleTurnToward(x,y,d){var angle = this.angleTo(x,y);if(angle< 180){
this.angle+=d;}else{this.angle-=d;}}function turtleSetColor(c){this.color=c;}
function turtleSetWeight(w){this.weight=w;}function turtleFace(angle){
this.angle = angle;}function makeTurtle(tx,ty){var turtle={x:tx,y:ty,
angle:0.0,penIsDown:true,color:color(128),weight:1,left:turtleLeft,
right:turtleRight,forward:turtleForward, back:turtleBack,penDown:turtlePenDown,
penUp:turtlePenUp,goto:turtleGoTo, angleto:turtleAngleTo,
turnToward:turtleTurnToward,distanceTo:turtleDistTo, angleTo:turtleAngleTo,
setColor:turtleSetColor, setWeight:turtleSetWeight,face:turtleFace};
return turtle;}

Starting this project, I really wanted crinkle-cut fries. Also, in one of the studio classes I am taking for design, we talked about color theory, so I decided to combine both the “crinkle-cut fries” idea and color theory into this project. It was definitely really fun to experiment with turtles.

first of four frames
last of four frames

Alexandra Kaplan – Project 11 – Composition

Press any key to restart!

/*
Alexandra Kaplan
aekaplan@andrew.cmu.edu
Section C
Project - 11
*/

function setup() {
    createCanvas(480, 480);
    background(250, 90, 15);
    
}

function draw() {

    var ttl1 = makeTurtle(240,240);
    var ttl2 = makeTurtle(240,240);
    var ttl3 = makeTurtle(width + width / 2, 240);
    var ttl4 = makeTurtle(width, 245);
    var ttl5 = makeTurtle(width * 2, 240);
    var tt2ColR = map(mouseY, 0, height / 2, 200, 50);
    

    // sand 1
    ttl1.penDown();
    ttl1.setWeight(10)
    col1 = color(250, 220, 200);
    ttl1.setColor(col1);
    for(var i = 0; i < 10; i++){
        ttl1.forward(-mouseY / 4);
        ttl1.right(-mouseX /50); 
        ttl1.left(mouseX/100)  
    }
    
    //sky
    ttl2.penDown();
    ttl2.setWeight(20);
    col2 = color(tt2ColR, 150, 225);
    ttl2.setColor(col2);
    for(var j = 0; j < 200; j++){
        ttl2.forward(mouseY / 4);
        ttl2.right(-mouseX / 50);
    }

     //sand 3
    ttl3.penDown();
    ttl3.setWeight(10);
    col3 = color(250, 230, 190);
    ttl3.setColor(col3);
    for(var i = 0; i < 10; i++){
        ttl3.forward(-mouseY / 4);
        ttl3.right(-mouseX / 50); 
        ttl3.left(mouseX / 100)  
    }
    //sand 2
    ttl4.penDown();
    ttl4.setWeight(10);
    col4 = color(250, 230, 200);
    ttl4.setColor(col4);
    for(var i = 0; i < 10; i++){
        ttl4.forward(-mouseY / 5);
        ttl4.right(-mouseX / 50); 
        ttl4.left(mouseX / 100);  
    }

    ttl5.penDown();
    ttl5.setWeight(10);
    col5 = color(250, 220, 200);
    ttl5.setColor(col5);
    for(var i = 0; i < 10; i++){
        ttl5.forward(-mouseY / 4);
        ttl5.right(-mouseX / 50); 
        ttl5.left(mouseX / 100);
    }

}

function keyPressed(){
    background(240, 90, 15);

}

function turtleLeft(d){this.angle-=d;}function turtleRight(d){this.angle+=d;}
function turtleForward(p){var rad=radians(this.angle);var newx=this.x+cos(rad)*p;
var newy=this.y+sin(rad)*p;this.goto(newx,newy);}function turtleBack(p){
this.forward(-p);}function turtlePenDown(){this.penIsDown=true;}
function turtlePenUp(){this.penIsDown = false;}function turtleGoTo(x,y){
if(this.penIsDown){stroke(this.color);strokeWeight(this.weight);
line(this.x,this.y,x,y);}this.x = x;this.y = y;}function turtleDistTo(x,y){
return sqrt(sq(this.x-x)+sq(this.y-y));}function turtleAngleTo(x,y){
var absAngle=degrees(atan2(y-this.y,x-this.x));
var angle=((absAngle-this.angle)+360)%360.0;return angle;}
function turtleTurnToward(x,y,d){var angle = this.angleTo(x,y);if(angle< 180){
this.angle+=d;}else{this.angle-=d;}}function turtleSetColor(c){this.color=c;}
function turtleSetWeight(w){this.weight=w;}function turtleFace(angle){
this.angle = angle;}function makeTurtle(tx,ty){var turtle={x:tx,y:ty,
angle:0.0,penIsDown:true,color:color(128),weight:1,left:turtleLeft,
right:turtleRight,forward:turtleForward, back:turtleBack,penDown:turtlePenDown,
penUp:turtlePenUp,goto:turtleGoTo, angleto:turtleAngleTo,
turnToward:turtleTurnToward,distanceTo:turtleDistTo, angleTo:turtleAngleTo,
setColor:turtleSetColor, setWeight:turtleSetWeight,face:turtleFace};
return turtle;}

For this project, I wanted to focus on mouse interactivity and how turtles could be used to create an overall picture. Using a few different turtles, I was able to make a desert landscape with different colors of sand and a sun that can be included depending on the person using it.

earlier iteration
final iteration with crescent sun
Final iteration

Sophie Chen – Project 11 – Composition

sketch

// Sophie Chen
// Section C
// sophiec@andrew.cmu.edu
// Project 11

var turtle;

function setup() {
    createCanvas(480, 480);
    background(0, 0, 0);    
    
}


function draw() {
    
    turtle = makeTurtle(width / 2 + 50, height + 50)
    //gradient color
    var g = map(mouseY, 0, height, 255, 0);
    var r = map(mouseY, 0, width, 10, 155);
    var col = color(r, g, 200);

    turtle.setColor(col);
    turtle.setWeight(2);
    var navY = map(mouseY, 0, 480, 480, 0); // navigation Y to scale of canvas
    var navX = map(mouseX, 0, 480, 480, 0); // navigation X to scale of canvas

    // not visible, sets distance between blobs
    for (var i = 0; i < 100; i++) {
        turtle.penUp();
        turtle.forward(navY / 2);
        turtle.left(90.4);
        turtle.forward(navX); 
        turtle.penDown(); 

    // blobs along path of previous for loop
        for (var j = 0; j < 100; j++){
        	turtle.setWeight(0.3);
        	turtle.right(200.5);
        	turtle.forward(100);
        	turtle.right(19.1);
        }

    }
 
}

/////////////////////////////////////////////

function turtleLeft(d){this.angle-=d;}function turtleRight(d){this.angle+=d;}
function turtleForward(p){var rad=radians(this.angle);var newx=this.x+cos(rad)*p;
var newy=this.y+sin(rad)*p;this.goto(newx,newy);}function turtleBack(p){
this.forward(-p);}function turtlePenDown(){this.penIsDown=true;}
function turtlePenUp(){this.penIsDown = false;}function turtleGoTo(x,y){
if(this.penIsDown){stroke(this.color);strokeWeight(this.weight);
line(this.x,this.y,x,y);}this.x = x;this.y = y;}function turtleDistTo(x,y){
return sqrt(sq(this.x-x)+sq(this.y-y));}function turtleAngleTo(x,y){
var absAngle=degrees(atan2(y-this.y,x-this.x));
var angle=((absAngle-this.angle)+360)%360.0;return angle;}
function turtleTurnToward(x,y,d){var angle = this.angleTo(x,y);if(angle< 180){
this.angle+=d;}else{this.angle-=d;}}function turtleSetColor(c){this.color=c;}
function turtleSetWeight(w){this.weight=w;}function turtleFace(angle){
this.angle = angle;}function makeTurtle(tx,ty){var turtle={x:tx,y:ty,
angle:0.0,penIsDown:true,color:color(128),weight:1,left:turtleLeft,
right:turtleRight,forward:turtleForward, back:turtleBack,penDown:turtlePenDown,
penUp:turtlePenUp,goto:turtleGoTo, angleto:turtleAngleTo,
turnToward:turtleTurnToward,distanceTo:turtleDistTo, angleTo:turtleAngleTo,
setColor:turtleSetColor, setWeight:turtleSetWeight,face:turtleFace};
return turtle;}

For this project I wanted to use turtle graphics to create something that allows the user to draw something that looks 3d, made up of the 2d patterns. I tested out a lot of different variations and ended up liking this one the most (the slower you move the mouse, the smoother the gradient). Overall I had a lot of fun with this, I’m definitely a lot more comfortable with turtle graphics now.

different iteration
another different iteration
final version

Kevin Thies – Looking Outwards 11


A user’s generated music

While looking at various computational instruments, I ended up on a small tangent that lead to the discovery of not a person, but a tool. Specifically, that tool was WolframTones, created 2005 by Wolfram Research, based on research from the 1980s. I found it interesting in that unlike what I looked at during week 4, this was a tool that was more centered around what I suppose you could call the formality of music. It allows for control over tempo, pitch mapping, and instrumentation. As an extra blessing or curse, the site had so many different options that one could really engross themselves. There are already hundreds of premade musical scales, instruments, and instrument roles. It’s crazy.
WolframTones is powered by Wolfram Automata. Basically, there’s a square that’s either black or white and it’ll gontinue to grow based on a specific rule, generating complexity. There are 256 rules, and Stephen Wolfram’s experiment went through all those rules. Hopefully this image explains it a little better.

The 256 Rules

WolframTones takes these rules and flips them sideways, and uses them as notes.
The above video is an example of someone using the website and their generated music.