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();
        }
    }
}







Timothy Liu — Project 10 — Sonic Sketch

Click on a drum to hear its sound!

tcliu-openended-10

// Timothy Liu
// 15-104, Section C
// tcliu@andrew.cmu.edu
// OpenEnded-10

// bass drum variables
var bassDrumW = 200;
var bassDrumX;
var bassDrumY;
var rimWidth = 20;
var bassRadius = bassDrumW / 2;

// high tom tom variables
var tomTomW = 100;
var tomTomH = 40;
var tomTomBaseW = 100;
var tomTomBaseH = 50;
var tomTomX1 = 220;
var tomTomY1 = 200;
var tomTomX2 = 380;
var tomTomY2 = 200;
var baseOffset = tomTomW / 2;
var tomTomRodW = 5;
var tomTomRodH = 250;
var httRodOffset = tomTomRodW / 2;
var hTTDRadius = 50;

// floor tom tom variables
var fTomTomW = 150;
var fTomTomH = 60;
var fTomTomBaseW = 150;
var fTomTomBaseH = 100;
var fTomTomX = 135;
var fTomTomY = 300;
var fBaseOffsetX = fTomTomW / 2;
var fBaseOffsetY = 100;
var fTomTomRodW = 8;
var fTomTomRodH = 100;
var fRodOffset = fTomTomRodW / 2;
var fTTDRadius = 95;

// snare drum
var snareW = 120;
var snareH = 40;
var snareBaseW = 120;
var snareBaseH = 30;
var snareX = 450;
var snareY = 275;
var snareOffsetX = snareW / 2;
var snareOffsetY = snareBaseH;
var snareRodW = 8;
var snareRodH = 200;
var snareRodOffset = snareRodW / 2;
var snareRadius = 50;

// cymbals
var cymbalX1 = [100, 130];
var cymbalY1 = [30, 150];
var cymbalZ1 = [170, 150];
var cymbalX2 = [500, 130];
var cymbalY2 = [570, 150];
var cymbalZ2 = [430, 150];
var cymbalRodH = 350;
var cymbalRodW = 4;
var cymbalOffset = cymbalRodW / 2;
var cymbalH = 20;

// variables for sounds
var hTTDSound;
var FTTDSound;
var bassDSound;
var cymbalSound;
var snareDSound;

// preload all the different drum sounds: snare, bass, high tom tom, floor tom tom, and cymbal
function preload() {
    snareDSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/snare.wav");
    snareDSound.setVolume(0.5);

    bassDSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/bass.wav");
    bassDSound.setVolume(0.9);

    hTTDSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/HTTD.wav");
    hTTDSound.setVolume(0.5);

    fTTDSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/FTTD.wav");
    fTTDSound.setVolume(0.5);

    cymbalSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/cymbal.wav");
    cymbalSound.setVolume(0.5);

}

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

function draw() {

    background(200, 200, 255); // blue background

    noStroke();

    highTomTomDrum(tomTomX1, tomTomY1); // calls the high Tom Tom Drum drawing function and places it at the first x, y
    highTomTomDrum(tomTomX2, tomTomY2); // calls the high Tom Tom Drum drawing function again and places it at the other x, y
    cymbals(cymbalX1, cymbalY1, cymbalZ1); // calls the cymbal drawing function and places it at the first x, y
    cymbals(cymbalX2, cymbalY2, cymbalZ2); // calls the cymbal drawing function again and places it at the other x, y
    floorTomTomDrum(fTomTomX, fTomTomY); // calls the floor Tom Tom Drum drawing function and places it at the given x, y
    snareDrum(snareX, snareY); // calls the snare drum drawing function and places it at the given x, y
    bassDrum(); // calls the bass drum drawing function

}

function mousePressed() {
    // play the high tom tom drum sound when the mouse is pressed on the left high tom tom drum
    if (insideHTTDrumLeft() === true) {
        hTTDSound.play();
    }

    // play the high tom tom drum sound when the mouse is pressed on the right high tom tom drum
    if (insideHTTDrumRight() === true) {
        hTTDSound.play();
    }

    // play the floor tom tom drum sound when the mouse is pressed on the floor tom tom drum
    if (insideFTTDrum() === true) {
        fTTDSound.play();
    }
    
    // play the bass drum sound when the mouse is pressed on the bass drum
    if (insideBassDrum() === true) {
        bassDSound.play();
    }

    // play the bass drum sound when the mouse is pressed on the snare drum
    if (insideSnare() === true) {
        snareDSound.play();
    }

    // play the bass drum sound when the mouse is pressed on the left cymbal
    if (insideCymbalLeft() === true) {
        cymbalSound.play();
    }

    // play the bass drum sound when the mouse is pressed on the right cymbal
    if (insideCymbalRight() === true) {
        cymbalSound.play();
    }
}

function insideHTTDrumLeft() {
    var dHTTDrumLeft = dist(mouseX, mouseY, tomTomX1, tomTomY1 + 30); // dist from mouse to center of left HTT Drum
    if (dHTTDrumLeft <= hTTDRadius) { // checks if the distance from mouse to the center is less than the radius of the HTT drum (which would mean it's inside the drum)
        return true;
    }
}

function insideHTTDrumRight() {
    var dHTTDrumRight = dist(mouseX, mouseY, tomTomX2, tomTomY2 + 30); // dist from mouse to center of right HTT Drum
    if (dHTTDrumRight <= hTTDRadius) { // checks if the distance from mouse to the center is less than the radius of the HTT drum (which would mean it's inside the drum)
        return true;
    }
}

function insideFTTDrum() {
    var dFTTDrum = dist(mouseX, mouseY, fTomTomX, fTomTomY + 75); // dist from mouse to center of FTT Drum
    if (dFTTDrum <= fTTDRadius) { // checks if the distance from mouse to the center is less than the radius of the FTT drum (which would mean it's inside the drum)
        return true;
    }
}

function insideBassDrum() {
    var dBass = dist(mouseX, mouseY, bassDrumX, bassDrumY); // dist from mouse to center of bass drum
    if (dBass <= bassRadius) { // checks if the distance from mouse to the center is less than the radius of the bass drum (which would mean it's inside the drum)
        return true;
    }
}

function insideSnare() {
    var dSnare = dist(mouseX, mouseY, snareX, snareY + 25); // dist from mouse to center of snare drum
    if (dSnare <= snareRadius) { // checks if the distance from mouse to the center is less than the radius of the snare drum (which would mean it's inside the drum)
        return true;
    }
}

function insideCymbalLeft() { // is the mouse inside the left cymbal?
    if (mouseX >= 30 & mouseX <= 170 && mouseY >= 130 && mouseY <= 150) { // checks if the mouse is inside the edges of the cymbal
        return true; 
    }
}

function insideCymbalRight() { // is the mouse inside the right cymbal?
    if (mouseX >= 430 & mouseX <= 570 && mouseY >= 130 && mouseY <= 150) { // checks if the mouse is inside the edges of the cymbal
        return true;
    }
}

function highTomTomDrum(x, y) { // function that draws the high tom tom drums (the 2 small middle ones)

    fill(64, 40, 15);
    rect(x - httRodOffset, y + baseOffset, tomTomRodW, tomTomRodH);

    fill(163, 47, 29);
    ellipse(x, y + baseOffset, tomTomW, tomTomH);
    rect(x - baseOffset, y, tomTomBaseW, tomTomBaseH);

    fill(255, 245, 212);
    ellipse(x, y, tomTomW, tomTomH);

}

function floorTomTomDrum(x, y) { // function that draws the floor tom tom drum (the bigger left one)

    fill(64, 40, 15);
    rect(x - fRodOffset, y + fBaseOffsetY, fTomTomRodW, fTomTomRodH);

    fill(163, 47, 29);
    ellipse(x, y + fBaseOffsetY, fTomTomW, fTomTomH);
    rect(x - fBaseOffsetX, y, fTomTomBaseW, fTomTomBaseH);

    fill(255, 245, 212);
    ellipse(x, y, fTomTomW, fTomTomH);
}

function bassDrum() { // function that draws the bass drum (the big round middle one)

    bassDrumX = width / 2;
    bassDrumY = 2 * height / 3;
    
    fill(163, 47, 29);
    ellipse(bassDrumX, bassDrumY, bassDrumW + rimWidth, bassDrumW + rimWidth)
    
    fill(255, 245, 212);
    ellipse(bassDrumX, bassDrumY, bassDrumW, bassDrumW);

}

function snareDrum(x, y) { // function that draws the snare drum (flatter one on right)

    fill(64, 40, 15);
    rect(x - snareRodOffset, y + snareOffsetY, snareRodW, snareRodH);

    fill(163, 47, 29);
    ellipse(x, y + snareOffsetY, snareW, snareH);
    rect(x - snareOffsetX, y, snareBaseW, snareBaseH);

    fill(255, 245, 212);
    ellipse(x, y, snareW, snareH);

}

function cymbals(x, y, z) { // function that draws the cymbals

    fill(64, 40, 15);
    rect(cymbalX1[0] - cymbalOffset, cymbalX1[1] + cymbalH, cymbalRodW, cymbalRodH);
    rect(cymbalX2[0] - cymbalOffset, cymbalX2[1] + cymbalH, cymbalRodW, cymbalRodH);
    fill(255, 227, 46);
    triangle(x[0], x[1], y[0], y[1], z[0], z[1]);

}

For my sonic sketch, I decided to build an interactive drum set. My drum set is comprised of a bass drum, 2 high tom-tom drums, a snare drum, a floor tom-tom drum, and 2 cymbals (as labeled in the diagram).

A labeled diagram of the different parts of my drum set. Each one, when clicked, makes a different sound!

The drum set took a while to create, as I wanted to create separate functions for each drum in order to simplify my draw function. After drawing the drums, I went to freesound.org and found audio files to match each of the drums. I then implemented the logic within mousePressed() to make sure that the sound played when the mouse clicked on the corresponding drum. I really enjoyed this project because it felt very systematic to program and it encouraged me to utilize various functions as well as ample amounts of logic. In addition, getting to learn how to preload sounds was beneficial for my development as a programmer!

Julia Nishizaki – Looking Outwards – 10

“Hello, World,” Iamus’s first complete composition, 2011

This week, I chose to look into the San Francisco startup, Melomics Media, and their computational system for automatically composing music. Melomics has created two “computer-musicians,” Iamus and Melomics109. Iamus is a computer cluster which is currently located at the Universidad de Málaga in Spain, where it was developed in 2010. Iamus composed “Opus One” on October 15, 2010, which was the first fragment of professional contemporary classical music to be composed by a computer in its own style, as it was not attempting to copy a previous composer’s work. A year later, “Helo, World,” Iamus’s first complete composition premiered, and in 2012, the London Symphony Orchestra recorded 10 of Iamus’s pieces, creating “Iamus,” the first studio album composed using this computational system.

The Iamus computer cluster

It takes Iamus 8 minutes to create a new composition and to output this data into multiple formats. According to the Universidad de Málaga’s website, the algorithm that Iamus uses is built on data-structures that act as genomes in order to create possible compositions.

While listening to “Hello, World” I was surprised by both how contemporary and dissonant the piece sounded, and how an entire, fairly coherent piece of chamber music could be composed by a computer. However, the constant tension in the piece, combined by the very human musicians and their interpretations gives “Hello, World” an uncanny valley feel, because the piece is technically music, but something still seems slightly off. I’m curious as to why Melomics decided to go in this direction, rather than to create music that is composed of “new” sounds and is entirely unplayable by humans.

Sarah Choi – Looking Outwards – 10

https://www.smule.com/

Smule is a startup company, co-founded by Ge Wang, exploring social mobile music-making into a unique platform for research and development combining music and computational algorithms. Ge Wang, Stanford’s assistant professor at Stanford’s Center for Computer Research in Music and Acoustics (CCRMA), has made a difference in combining programming languages and interactive software with computational music. 

This music-making application through social media gives a space for the public to portray their individual styles by showing how they think, work, and play through sound and music. Smule’s algorithm generates sounds and video from one’s device and synchronizes the two streams in real-time. It uses audio processing to create more effects such as duets, so one doesn’t have to go through the process of editing his or her own video and sound. It also has available transitions to make the music more of one’s own. 

Ge Wang talks a lot about how technology shapes us to be more individualistic and how we can use technology to express ourselves to the public. Because of this, Smule’s final form manifests Ge Wang’s passion to create a platform for everyone to do exactly this. His application has been able to reach millions as people appreciate others’ true art forms.

Min Ji Kim Kim – Looking Outwards – 10

Overview of the Prélude in ACGT project by Pierry Jaquillard.

Prélude in ACGT, created by Pierry Jaquillard at the Media and Interaction Design Unit at ECAL, utilizes Jaquillard’s own DNA chromosomes data and transforms it to generate sound. This project created through JavaScript, midi and Ableton Live, consists of  five interfaces. Two of the interfaces allow the user to control features such as tempo or musical arrangement while the other three, visualize sound, the algorithm type and the DNA itself. The user can also export the midi file to record and generate a musical score using music notation software.

User interface screens of the different features that can be controlled to manipulate the sound.

I really admire this project because it seamlessly combines the field of human biology with computer science. The idea of “coding” DNA is quite practically literally represented in this project. Furthermore, I believe that this project has endless possibilities. No one’s DNA is the same which means that using this software, we would be able to create extremely unique pieces of music. 

552 page musical score representing 0.2% of Jaquillard’s DNA.

Lauren Park – Looking Outwards – 10

Artist Cyrill Studer created a music video of “Baby Behold” for a band called Carvel’ on May 5, 2017. Because this song contained electronically and upbeat tunes, the artist decided to use different forms of an ellipse that match the rhythm of the song. I really admire how video making interacts with algorithm in this piece, where color, shifting and moving shapes can represent the overall vibe of the song and make it easy for listeners to be hooked by the beat of the music. I personally enjoyed this very simplistic visual concept of one ellipse going through different changes as the song progresses.  These visuals were created by translating code in the program called Processing. And then After Effects was used for video editing.

The artist  was aiming to create computer graphics that take on an older, vintage look. And the simple pattern of how the ellipse moves as well as the dark teal color does seem to remind us of an old-fashioned  reference to how older computers looked when it ran. This seems to be successful especially when the music has electronic elements that combines harmoniously with this visual theme. 

https://cyrillstuder.ch/carvel-baby-behold

Carvel’ – Baby Behold(2017) by Cyrill Studer

Claire Lee – Looking Outwards – 10

I decided to write about a short musical piece created by computer music artist and pioneer Laurie Spiegel called Strand of Life (‘Viroid’). I did listen to several other pieces in her album Unseen World, but Strand of Life was really fascinating to me because of both the conception and the result. This piece also interested me because it was so similar in concept to the sound art piece I wrote about in my Looking-Outwards-04, Pierry Jacquillard’s Prélude in ACGT, so I was interested to see each artist’s unique approach to the concept of generating music with patterns derived from genetic material.

Spiegel got the idea for this piece while she was sick with an infection-taking that as inspiration, she converted a viroid’s DNA into midi data and used that as the base for her musical track. I imagine that the algorithm behind the DNA-midi conversion was relatively straightforward, but she incorporates other elements (vocals, instrumentals) that were also partly computer-generated that make the piece much more complex than the sound art I wrote about previously.

Sammie Kim – Project 10 – Sonic Sketch

sketch

//Sammie Kim
//Section D
//sammiek@andrew.cmu.edu
//Project 10 - Sonic Sketch

//Global variables
var facesPic;
var laughingSound;
var cryingSound;
var surprisedSound;
var angrySound;

function preload() {
    //loading image through Imgur
    var facesURL = "https://i.imgur.com/1fPz3CY.jpg";
    facesPic = loadImage(facesURL);
    //loading sound from freesound.org
    laughingSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/laughing.wav");
    cryingSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/crying.wav");
    surpriseSound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/surprise.wav");
    angrySound = loadSound("https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2019/11/angry.wav");
}

function setup() {
    createCanvas(460, 200);
    background(255);
    useSound();
}

function soundSetup() {
    // setup for audio generation
    //setting volume to one for each sound
    laughingSound.setVolume(1);
    cryingSound.setVolume(1);
    surpriseSound.setVolume(1);
    angrySound.setVolume(1);
}

function draw() {
    //drawing out the image on the canvas
    background(255);
    image(facesPic, 0, 0);
}

function mousePressed() {
    //making each sound play and pause based on mouse location on canvas
    if (mouseX > 0 & mouseX < 140 ) {
        surpriseSound.play();
        } else {
        surpriseSound.pause();
        }
    if (mouseX > 140 & mouseX < 230) {
        cryingSound.play();
        } else {
        cryingSound.pause();
        }
    if (mouseX > 230 & mouseX < 336) {
        angrySound.play();
        } else {
        angrySound.pause();
        }
    if (mouseX > 336 & mouseX < width) {
        laughingSound.play();
        } else {
        laughingSound.pause();
        }
}

For this project, I wanted to incorporate sounds that show the emotions of each minion ( happy, sad, surprised, and angry). It took a while to get used to working with terminal and preloading sounds, but I feel I got a better grasp now.

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