Category: SectionE

Jina Lee – Looking Outwards 10

This is an image of what The Cycling Wheel is.

This week I decided to look at Keith Lam, Seth Hon and Alex Lai’s The Cycling Wheel. This project utilized Arduino as well as other processing softwares to make the bicycle an instrument of light and sound. I was drawn to this project, because I am currently taking an Introduction to Arduino class. I was intrigued with how they use this application because I can barely make an LED light turn on and off. When you turn the wheel of the bicycle, it turns different aspects such as the music and light bean and color of the light would be altered. The bike itself becomes an instrument and the controllers of the wheel become the musician. This concept is something I have never seen and thought it was so extremely creative.

With this project I admire how it allows anyone to become a musician. From my limited experience with Arduino, I am assuming that they were able to alter the color of the LED strip though the influence of the motion of the wheel. I am still unsure how they were able to connect the motion of lights with sound. I think this is a great example of how someone can incorporate sound with computational lights.

This is another image of The Cycling Wheel.

Joseph Zhang – Project 10 – Sonic Sketch

sketch

// Joseph
// Section E
// Project 10 - Sonic 

var px, py;
var diam = 30;
var distance = 20;
var count = 0;

//load sounds
function preload() {
    up = loadSound('https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/up.wav');
    right = loadSound('https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/right.wav');
    left = loadSound('https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/left.wav');
    down = loadSound('https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/down.wav');
    warningSound = loadSound('https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/warning.wav');
}

function setup() {
    // you can change the next 2 lines:
    createCanvas(400, 400);
    px = width/2;
    py = height/2;
    dx = 0;
    dy = 0;
    useSound();
}

// for some reason wont work if not included
function soundSetup() {
}

function draw() {
    background(200, 220, 250);

    //red background - DANGER
    if(px < 50 || px > 350 || py < 50 || py > 350){
        background('red');
        fill('black');
        text("COME BACK!", width / 2 - 40, height / 2);
    }
    //blue background - SAFE
    else {
        background(200, 220, 250);
        fill('black');
        text("DON'T CROSS THE LINE ;)", width / 2, 30);
    }

    //creating movable circle, square boundary, and directions

    if(count === 0){
        text('UP / DOWN / LEFT / RIGHT ARROWS TO MOVE', 67, height - 20);
    }

    rectMode(CENTER);
    noFill();
    rect(width/2, height/2, 300, 300);


    //change color if inside/outside of boundary box
    if(px > 350 || px < 50 || py > 350 || py < 50){
        fill('blue');
    } else {
        fill('yellow');
    }

    //draw ellipse
    ellipse(px, py, diam, diam);

    //when the ball moves off the screen
    if(px < 0){
        px = height - diam/2;
    } if(px > width){
        px = 0;
    }
}

function keyPressed() {
    //press left key
    if (keyCode === LEFT_ARROW) {
        px -= distance;
        if(px < 50 || px > 350 || py < 50 || py > 350){
            warningSound.play();
        }
        else{
            left.play();
            warningSound.stop();
        }
        count++;
    }
    //press right key
    else if (keyCode === RIGHT_ARROW) {
        px += distance;
        if(px < 50 || px > 350 || py < 50 || py > 350){
            warningSound.play();
        }
        else{
            right.play();
            warningSound.stop();
        }
        count++;
    }
    //press up key
    else if (keyCode === UP_ARROW) {
        py -= distance;
        if(px < 50 || px > 350 || py < 50 || py > 350){
            warningSound.play();
        }
        else{
            up.play();
            warningSound.stop();
        }
        count++;
    }
    //press down key
    else if (keyCode === DOWN_ARROW) {
        py += distance;
        if(px < 50 || px > 350 || py < 50 || py > 350){
            warningSound.play();
        }
        else{
            down.play();
            warningSound.stop();
        }
        count++;
    }
}

In this project, I used the metaphor of the ball as me as a young adult. There are boundaries that we’re given and often times we’re tempted to cross them. We’re often warned, but we’re not stopped. Ultimately, it’s up to us.

YouieCho-LookingOutwards-10

“Queer Trash Presents: Max Hamel.” Performance on April 12, 2019 by Max Hamel

This is a performance of gender blur, noise abstraction, and intimate electricity. The event in which this performance happened is Queer Trash, which celebrates the potential for noise to be a process that undoes fixed meanings, upsets hierarchies, and also collapses socially constructed order, although it is often considered something inevitable but unwanted. Max Hamel represents noise as something with an independent meaning itself, as something queer. I couldn’t find much about an algorithm that goes behind this work, but I think the randomness of noise is the nature of what he wants to express. I can see that he is controlling the various computational noise with his hands, and there are sections that are more defined with fewer amount of sounds, and other sections that are a combination of many sounds. I think this is very sensible of him to create levels of intensity, which is what often happens in music.

https://issueprojectroom.org/video/queer-trash-presents-max-hamel

Caroline Song – Looking Outwards 10 – Computer Music

The installation of sound art that I will be looking at this week is called “Cycling Wheel“ by Keith Lam, Seth Hon, and Alex Lai, made in 2017.

“Cycling Wheel” Installation

This piece of art was inspired from the Bicycle Wheel piece made by Marcel Duchamp. It borrows the concept from Duchamp and redesigns it as an interactive and performative installation piece.

I was attracted to this project because of the way it reimagines something as simple as a bicycle wheel (which is an object that is commonly known), into an interactive art piece that brings dynamic motion through light and sound to this static object. It takes the bicycle wheel and allows the audience to imagine it when it actually is functioning through an entire bicycle. Furthermore, it takes the experience of biking one step further by introducing sound and light into the mechanics, which is not the typical way you experience biking. The most intriguing thing about this piece is how the artists have managed to reimagine such a well-known activity that most people experience into something new, which shows their artistic sensibilities coming out in their want to allow their audience to experience a sensation that they’ve been familiar with in a new way, using computational art instead of traditional art.

The algorithms that the artists seem to have used include “tailor made control panel software”. This is through the open source programming language, Processing. They also have used programs like Arduino, as well as using different units in order to control different areas of the piece, such as the control of the music, the control of the light beams, and the control of the LED strips.

YouieCho-Project-10-Sonic-Sketch


sketch

/* Youie Cho
   Section E
   minyounc@andrew.cmu.edu
   Project-10-Sonic-Sketch*/

var mySndC;
var mySndCs;
var mySndD;
var mySndDs;
var mySndE;
var mySndF;
var mySndFs;
var mySndG;

function preload() {
    // Load sound files for each key
    mySndC = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/c-6.wav");
    mySndCs = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/cs.wav");
    mySndD = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/d-4.wav");
    mySndDs = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/ds.wav");
    mySndE = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/e-2.wav");
    mySndF = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/f-6.wav");
    mySndFs = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/fs.wav");
    mySndG = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/g-4.wav");
    // Set volume to 1
    mySndC.setVolume(1);
    mySndCs.setVolume(1);
    mySndD.setVolume(1);
    mySndDs.setVolume(1);
    mySndE.setVolume(1);
    mySndF.setVolume(1);
    mySndFs.setVolume(1);
    mySndG.setVolume(1);
}

function setup() {
    createCanvas(600, 600);
}

function draw() {
    background("pink");
    strokeWeight(2);
    // Draw white keys
    fill(255);
    for (i = 0; i < 5; i++) {
        rect(120 + i*70, 150, 70, 250);
    }
    // Draw black keys
    fill(0);
    rect(170, 150, 40, 150);
    rect(240, 150, 40, 150);
    rect(380, 150, 40, 150);
}

function mousePressed() {
    // Within the height range of white keys
    if (150 < mouseY & mouseY < 400) {
        // C sharp and C
        if (170 < mouseX & mouseX < 210 & 150 < mouseY & mouseY < 300) {
            mySndCs.play();
        } else if (120 < mouseX & mouseX < 190) {
            mySndC.play();
        }
        // D sharp and D
        if (240 < mouseX & mouseX < 280 & 150 < mouseY & mouseY < 300) {
            mySndDs.play();
        } else if (210 < mouseX & mouseX < 260) {
            mySndD.play();
        }
        // E
        if (280 < mouseX & mouseX < 330) {
            mySndE.play();
        }
        // F sharp and F
        if (380 < mouseX & mouseX < 420 & 150 < mouseY & mouseY < 300) {
            mySndFs.play();
        }else if (330 < mouseX & mouseX < 400) {
            mySndF.play();
        }
        // G
        if (420 < mouseX & mouseX < 470) {
            mySndG.play();
        }
    }
}







Mihika Bansal – Looking Outwards – 10

For this post I will be looking at the project, Sounding Circuits – Audible Histories. This piece is an interactive audio system surrounded by rare objects, artifacts, and recordings from the early history of electronic music. It was installed at Columbia University with their Department of Music. this exhibition highlights the significant contributions of pioneering electronic and computer music composers Otto Luening, Pauline Oliveros, Edgar Varèse, and Charles Dodge. The piece specifically highlights the manner in which their different way of thinking caused so much progress in the music world.

The audio itself is presented in a 360 degree manner causing the users to become completely immersed into the space. This piece was curated by Seth Cluett.

Image of the exhibit space
Video that displays what the exhibit is like

Mihika Bansal – Project 10 – Sonic Sketch

sketch


// Mihika Bansal 
// Section E 
// mbansal@andrew.cmu.edu
// Project 10

var h1 = 35; // varying heights
var h2 = 80;  
var h3 = 50; 

var w1 = 10; //varying widths 
var w2 = 15; 
var w3 = 20; 


function preload() {
    // call loadImage() and loadSound() for all media files here
    //mySnd = loadSound("waves.wav"); 
   // mySnd.setVolume(0.5);
}


function setup() {
    // you can change the next 2 lines:
    rectMode(CENTER); 
    createCanvas(480, 400);
   
    //======== call the following to use sound =========
    useSound();
}


function soundSetup() { // setup for audio generation
    // you can replace any of this with your own audio code:
    s1 = new p5.Oscillator(); //the 4 tones I will be manipulating
    s1.setType('sine');

    s2 = new p5.Oscillator();
    s2.setType("sine"); 

    s3 = new p5.Oscillator();
    s3.setType("sine"); 
    
    s4 = new p5.Oscillator();
    s4.setType("sine"); 

    //starting all the audio files, so all sounds are playing at the same time
    s1.start();
    s2.start(); 
    s3.start();
    s4.start();

}


function draw() {

    //creating visual elements 
    background(15); 
    noStroke(); 

    h1 = map(mouseY, 0, height, 50, 80); 
    h2 = map(mouseX, 0, height, 100, 200);
    h3 = map(mouseY, 0, height, 80, 120); 

    w1 = map(mouseX, 0, width, 10, 30);
    w2 = map(mouseY, 0, width, 20, 40);
    w3 = map(mouseX, 0, width, 15, 35); 

    fill("#355C7D"); 
    rect(26, 200, w1, h1); 
    rect(185, 200, w1, h1);
    rect(344, 200, w1, h1);


    fill("#F67280"); 
    rect(79, 200, w2, h2);
    rect(238, 200, w2, h2);
    rect(397, 200, w2, h2);

    fill("#C06C84"); 
    rect(132, 200, w3, h3);
    rect(291, 200, w3, h3);
    rect(450, 200, w3, h3);

    if(mouseX > 0 & mouseX < 120){ //determing sound based on the mouse, moving the mouse changes the sound
        freq1 = map(mouseX, 0, width, 0, 200); //lowest frequency is to the left of the screen
        //amp1 = map(mouseY, 0, height, 0, 0.3); 
        s1.freq(freq1); 
        s1.amp(0.5); //when in that section of the screen the audio is louder
        //s1.start(); 
    }
    else{
        s1.amp(0); //when outside of that section of the screen, the audio is softer 
    }
    if(mouseX > 120 & mouseX < 240){
        freq2 = map(mouseX, 0, width, 200, 400); // increeasing frequency
        s2.freq(freq2);
        s2.amp(0.5); // louder sounds
        //s2.start(); 
    }
    else{
        s2.amp(0); //softer sounds 
    }
    if(mouseX > 240 & mouseX < 360){
        freq3 = map(mouseX, 0, width, 400, 600); // increasing the frequency 
        s3.freq(freq3);
        s3.amp(0.5); //louder sound
        //s3.start(); 
    }
    else{
        s3.amp(0); //softer sound  
    }
    if(mouseX > 360 & mouseX < 480){
        freq4 = map(mouseX, 0, width, 600, 800); //final increase in the frequency
        s4.freq(freq4);
        s4.amp(0.5);
        //s4.start(); 
    }
    else{
        s4.amp(0);  
    }

}

With this project, I created a sound piece that depends on the location of the mouse on the page. When the mouse is off of the screen the sound stops, but as long as it is on the page, a frequency will be emitted. The visuals correspond with the sound that is being emitted because I used the map function for both. Move the mouse completely to the left to stop emitting the sound on wordpress.

Looking Outwards 10- Alice Cai

What do machines sing of?

“And I will always love you…” 
This sound art by Martin Backes blurs the lines of AI and humans but at the same time makes it all the more clear. Martin Backs feeds a computed system number-one ballads from 1990, and all of them are extremely EMOTIONAL songs. He has the computer reproduce the song with its own “emotional interpretations”. The machine attempts to replicate the human sentiment in the original song. While I listen to the machine, I can hear what seems to be crescendos and decrescendos as well as vibratos in the notes. However, it is glitchy and very clearly electronically made. You can tell that code is constantly running during the song.
The code is calculating current pitch, found pitch, frequency, and loudness. 



I find this project extremely intriguing because I was actually very impressed with the replication of the song by the machine. However, because of the clear distinctions and flaws in the replication, it also reassures me that human emotion is the one thing that cannot be replaced by electronics.

Project 10 Sonic Sketch- Alice Cai

SK

//alcai@andrew.cmu.edu
//AliceCai
//Project 10
//Section E

//load all the sound links and set the volume
function preload() {
    a = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/217214__goldkelchen__slap-in-the-face-1.wav");
    b = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/148997__adam-n__slap-2-1.wav");
    c = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/421876__sventhors__ouch-2.wav");
    d = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/348244__newagesoup__punch-boxing-01.wav");
    a.setVolume(1);
    b.setVolume(1);
    c.setVolume(1);
    d.setVolume(1);
}

function setup() {
    createCanvas(400, 400);
    background(200, 220, 250);
}

function draw() {
    //color change if mouse is pressed
    //draw face
    if (mouseIsPressed) {
        fill('red');
        noStroke();
        ellipse(width/2,height/2,400,400);
    } else {
        fill('yellow'); 
        noStroke();
        ellipse(width/2,height/2,400,400);
    }

    fill('black');
    ellipse(width/4,height/5 *2 ,30,60);
    ellipse(width/4 * 3,height/5 *2 ,30,60);
    //change to tears when face is hit
    if (mouseIsPressed) {
        fill('blue')
        ellipse(width/4*3, height/5* 3,20,50);
        ellipse(width/4, height/5* 3,20,90);
    } else {
        fill('pink');
        arc(width/2, height/1.8, 200, 200, 0, PI, PI);
    }

    print(mouseIsPressed);
}

function mousePressed (){
    //call different sounds for where the mouse is clicked
    if (mouseX < width/2 & mouseY > height/2) {
        a.play();
    }

    if (mouseX > width/2 & mouseY < height/2) {
        b.play();
    }

    if (mouseY > height/2 & mouseX > height/2) {
        c.play();
    }

    if (mouseY < height/2 & mouseX < width/2) {
        d.play();
    }
}

This is my sound project. It plays four sounds when the mouse clicks (or “hits) the face: big slap, small slap, punch, and OOF!, depending on where the mouse is clicked (four quadrants). When the mouse is clicked the face turns red and starts crying too! I thought it would be funny and simple.

Jamie Park – Project 10

sketch

//Jamie Park (jiminp)
//Project 10
//Section E

//global variables of the picture and sound files
var instrumentPic;
var bellSound;
var pianoSound;
var drumSound;
var guitarSound;

//feature that determines whether the file gets played or paused
var pianoPlaying = 1;
var drumPlaying = 1;
var guitarPlaying = 1;

function preload() {
    //preloads the image
    var instrumentURL = "https://i.imgur.com/dX3rHBT.jpg";
    instrumentPic = loadImage(instrumentURL);

    //preloads the sound files
    bellSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/Bell.wav");
    pianoSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/Piano.wav");
    drumSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/Drum.wav");
    guitarSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/10/guitar.mp3");
}

function setup() {
    //setup the canvas and prepare for the sound system
    createCanvas(450, 450);
    background(0);
    useSound();
}

function soundSetup() {
    //set the sound volume
    bellSound.setVolume(0.3);
    pianoSound.setVolume(0.3);
    drumSound.setVolume(0.3);
    guitarSound.setVolume(0.3);
}

function draw() {
    // draw the image
    image(instrumentPic, 0, 0);
}

function mousePressed(){
    //the sound files are triggered when mouse is pressed
    if (mouseX > width / 2 & mouseY > height / 2
    && mouseX < width && mouseY < height){
    //if a specific part of a canvas is clicked, add 1 to variable drumPlaying
        drumPlaying = drumPlaying + 1;
        if (drumPlaying % 2 == 0){
            //if drumPlaying is divisible by 2, play the sound file
            //if it is not divisible by 2, pause the sound file
            drumSound.play();
        } else {
            drumSound.pause();
        }
    }

    if (mouseX > width / 2 & mouseY < height / 2 && mouseX < width){
        pianoPlaying = pianoPlaying + 1;
        if (pianoPlaying % 2 == 0){
            pianoSound.play();
        } else {
            pianoSound.pause();
        }
    }

    if (mouseX < width / 2 & mouseY > height / 2 && mouseY < height){
        /*+1 play/pause does not apply to the bell,
        because the sound is relatively short and does not create a melody*/
        bellSound.play();
    }

    if (mouseX < width / 2 & mouseY < height / 2){
        guitarPlaying = guitarPlaying + 1;
        if (guitarPlaying % 2 === 0){
            guitarSound.play();
        } else {
            guitarSound.pause();
        }
    }
}

I created a sonic sketch by making an interactive file that makes sounds when clicked on corresponding icons. When you click on the guitar icon, the file will create guitar noise, and the same idea applies to the piano, drum, and the bell. The file can execute various types of sounds at the same time. I am happy that I figured out a logical way to make the sound stop when the mouse has clicked the corresponding icon again.