Gretchen Kupferschmid-Looking Outwards-04

Mixing both art with experience design, the hotel Sister City in NYC has a special sound installation in their lobby. Through a collaboration between musician and composer Julianna Barwick and Mircrosoft this project utilized Microsoft’s Custom Vision Service which utilizes artificial intelligence to track and analyze various elements of the Sister City environment through a camera on the roof. Through this knowledge, it then triggers the sound specific to what the camera has recognized. For example, clouds play a different sound than birds, and as things occur in the environment, a “song” is produced in the lobby. I find this extremely interesting because it creates a generative music installation that although is very technical, its being made by the natural environment around you. It also allows Barwick to see her own sound scores become something of their own as they are controlled by “outside forces”.

A video describing the project

https://www.microsoft.com/inculture/musicxtech/sister-city-hotel-julianna-barwick-ai-soundscape/

Yoshi Torralva – Looking Outwards – 04

A video showcasing Janet Cardiff’s process in creating The Forty Part Motet sound sculpture.

The Forty Part Motet fits within an emerging fine arts category — sound sculpture. Created by Janet Cardiff and first installed in 2001, the artist uses 40 speakers to create an experience that transports oneself into a choir. Each speaker only emits a single recording of a singer in the Salsbury Cathedral Choir. What this does is heighten the experience of being in the actual cathedral. Additionally, one can move around the speakers to have the feeling as if they were immersed in the choir floor. What I admire about this is that it uses technology in a way that is founded on creating a compelling human experience. Each speaker represents the individuality of the singular singer and allows for the opportunity for the viewer to partake in different listening experiences. A customized algorithm to channel the individual sound recordings to individual speakers most likely had to be used. Much explanation wasn’t provided on the technical aspects, but the program used most likely had to implement various channelings to different audio recordings and speaker inputs. What I find very interesting is that the artist focuses on the limitation of unnecessary visual elements to heighten the powerful voices within this installation.

Caroline Song – Project 04 – String Art

sketch

//Caroline Song
//chsong@andrew.cmu.edu
//Section E
//Project-04 

function setup (){
    createCanvas(400, 300);
}

function draw(){
    background("black");

    //blue lines on bottom left
    for(var i = 0; i < 300; i += 1.5) {
        stroke(161, 236, 255);
        strokeWeight(0.3);
        line(0, i * 5, i * 5, height);
    }

    //blue lines on top right
    for(var i = 0; i < 400; i += 1.5) {
        stroke(161, 236, 255);
        strokeWeight(0.3);
        line(width, i * 5, i * 5, 0);
    }

    //pink lines which turns in the middle
    for(var i = 0; i < 400; i += 1.5) {
        stroke(255, 201, 244);
        strokeWeight(0.3);
        line(height, -i * 4, i * 4, width - 100);
    }

    //yellow lines in the very front
    for(var i = 0; i < 600; i += 5) {
        stroke(207, 207, 145);
        strokeWeight(0.3);
        line(i * 4, height, -i * 4, 0);
    }

}


During the project, I wanted to experiment with the contrast between the dark color of the background and the lighter colors of the lines. I wanted to also look at the how the lines interact with each other in both form and color. Looking at the final product, it reminds me a little bit of laser beams in the dark.

Mihika Bansal – Project 04 – String Art

sketch

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

var x1Step = 5; 
var y1Step = 5; 

function setup() {
    createCanvas(400, 300);
   
  }

function draw() {

    background (255); 
    fill(0); 
    rect(50, 0, 300, 300); 

    stroke(255, 251, 217); 
    for(var j = 1; j <= 30; j++){
        line(50, 0 + y1Step * j, width / 2 - x1Step * j, 0); 
    } // curve with flats on left and top in the top left curving downwards 
    for(var j = 1; j <= 30; j++){
        line(50, height - y1Step * j, width / 2 - x1Step * j, height); 
    } // curve with flat on left and bottom, bottom left, curving upwards 
    for(var j = 1; j <= 30; j++){
        line(width - 50, height / 2 - y1Step * j, width - 50 - x1Step * j, 0); 
    } // curve with flat on top and right, top right, curving downwards 
    for(var j = 1; j <= 30; j++){
        line(width - 50, height / 2 + y1Step * j, width - 50 - x1Step * j, height); 
    } // curve with flat on right and bottom, bottom right, curving upwards

    stroke("white"); 
    for(var i = 1; i <= 30; i++){
        line(width / 2, 0 + y1Step * i, width / 2 + x1Step * i, height / 2); 
    } //curve starting in middle on top right, curving upwards, flat side is in middle of canvas
    for(var x = 1; x <= 30; x++){
        line(width / 2, height - y1Step * x, width / 2 + x1Step * x, height / 2); 
    } // curve starting in the middle on bottom right, curving downwards, flat sides are on the middle of canvas 
    for(var x = 1; x <= 30; x++){
        line(50 + x1Step * x, 0, width / 2, 0 + y1Step * x); 
    } //curve on top left , with flat part on top and middle, curving downwards
    for(var x = 1; x <= 30; x++){
        line(50 + x1Step * x, height, width / 2, height - y1Step * x); 
    } // curve on bottom left, with flat on bottom and middle, curving downwards

    stroke (194, 237, 231)
    for(var j = 1; j <= 30; j++){
        line(width / 2, 0 + y1Step * j, width / 2 - x1Step * j, height / 2); 
    } // curve in top left, with flat part in middle on both sides, curving upwards
    for(var j = 1; j <= 30; j++){
        line(width / 2, height / 2 + y1Step * j, width / 2 + x1Step * j, height); 
    } // curve  in bottom left, with flat in middle, curving downwards 
    for(var j = 1; j <= 30; j++){
        line(50 + x1Step * j, height / 2, width / 2, height / 2 + y1Step * j); 
    } // curve with flat in the middle and bottom, in the bottom right, curve upwards
    for(var j = 1; j <= 30; j++){
        line(width / 2 + x1Step * j, 0, width / 2, height / 2 - y1Step * j); 
    } // curve with flats on the top and the middle, in the top right, curve downwards 

    stroke(252, 204, 212); 
    for(var j = 1; j <= 30; j++){
        line(50, height / 2 - y1Step * j, width / 2 - x1Step * j, height / 2); 
    } // flat on the left side and the middle, curve upwards, in the top left 
    for(var j = 1; j <= 30; j++){
        line(50, height - y1Step * j, 50 + x1Step * j, height / 2); 
    } // flat on the left and the middle, in the bottom left, curve downwards
    for(var j = 1; j <= 30; j++){
        line(width - 50, height / 2 - y1Step * j, width / 2 + x1Step * j, height / 2); 
    } // flat on the middle and middle, in the top right, curving upwards
    for(var j = 1; j <= 30; j++){
        line(width - 50, height - y1Step * j, width - 50 - x1Step * j, height / 2); 
    } // flat on the right and the middle, in the bottom right, curbing downwards 
 
}

I really enjoyed this project. I have made string art before by hand using the actual string and nails and wood, so it was interesting making it through the computer this time.

Angela Lee – Project – 04

sketch

/*
 * Angela Lee
 * Section E
 * ahl2@andrew.cmu.edu
 * Project 4 String Art
 */

function setup() {
    createCanvas(400, 300);
    background("black");
}

function draw() {
    spacing1 = 40;
    spacing2 = 10;
    spacing3 = 5;
    red = mouseX;
    green = mouseX;
    blue = mouseY

    // LOOP FOR OUTERMOST STRINGS
    // the strings span the boundary of the canvas
    for(var a = 0; a <= 400; a += spacing1){
        // left bottom strings
        stroke(red, 0, 162);
        line(0, a, a, 300);

        // right top strings
        stroke(153, green, 0);
        line(400, a, a, 0);
    }

    // LOOP FOR GREEN, BLUE STRINGS
    // the strings are contained by the outermost strings 
    for(var b = 0; b <= 200; b += spacing2){
        stroke(0, 187, mouseY);
        // left top strings
        line(100 + b, 50, 100, 250 - b);
        // right top strings
        line(100 + b, 250, 300, 250 - b);
    }

    // LOOP FOR INNERMOST SQUARE
    // the strings are contained within a box 
    // the box specs: rect(150, 100, 100, 100)
    for(var a = 0; a <= 100; a += spacing3){
        // bottom left
        stroke(red, green, 162);
        line(150, 100 + a, 150 + a, 200);

        // top left
        stroke(150, green, blue);
        line(150 + a, 100, 150, 200 - a);

        // top right
        stroke(red, 150, blue);
        line(150 + a, 100, 250, 100 + a);

        // bottom right
        stroke(red, 100, blue);
        line(250, 100 + a, 250 - a, 200);

    }


}

For this project, I wanted to make a composition that had a fixed form but some element that was controlled by the user. I stuck to a strict geometry that relied on square and rectangle boundaries but allowed the colors of the strings to change based on the users’ mouse position.

Some of my notes when planning: first, it took me a while to understand how to program the string curves nicely. Then, I planned out the composition I wanted in my final piece.

Alice Cai Project 4

sketch

//Alice Cai
//alcai
//project#4
//Section E

//global variables
var x;
var y;
var aY;
var aX;

function setup() {
    createCanvas(480, 240);
    strokeWeight(3);
}

function draw() {
//background
    background(200) ;
    strokeWeight(1);

//defining variables 
    aX = mouseX
    aY = mouseY
    x = x * aY
    y = y * aX

//orange lines

    stroke('orange');
    for (var y = 100; y < 10000; y += 5) {
    line(y, aY, width - aX, y);
    line(y, aY, height - aY, y);

    }
//pink lines
    stroke('pink');
    for (var x = 100; x < height; x += 5) {
    line(x, aX, x, aY);
    line(aY, x, x, aX);

    }
//blue lines
    stroke('blue');
    for (var y = 100; y < width; y += 5) {
    line(aX, x, y, aY);
    line(aX, x - y - x, y, aY);

    }
//color changing
    stroke(mouseX,mouseY,mouseY);
    for (var y = 100; y < width; y += 5) {
    line(aX, x - aX, x, aY);
    line(aX, y - aX, y, aY);
    line(aY, y - aX, y, aX);
    }

}

This is my string art. At first, all my curves looked the same because I only used an i variable. After I added more the drawing became more dynamic. Each curve is drawn by a series of lines that are slightly shifted using a for loop and small increments that tilt the line and form a curve.

Alice Cai Looking Outwards 4

http://www.pamelaz.com/carbonsongcycle.html

EXCERPTS OF CARBON SONG CYCLE

Carbon Song Cycle

Pamela Z is a composer and performer who worked with media artist Christina McPhee on a project called Carbon Song Cycle. This project was fro a chamber ensemble and expanded cinema. The project reflects the progressions in the Earth’s ecosystem, focusing on the carbon cycle, which is the cycle of carbon through nature and life. Pamela took data on the carbon cycle, environmental balance and imbalance and created a melody inspired by the data. She also created drawings and images inspired by the carbon process, focusing on heat and chemical transformations in the process. She also took video footage from petroleum fields, natural gas locations, and geothermal sites. The melody was written for an ensemble of voice, electronics, viola, cello, bassoon, percussion, as well as an array of video projections. Throughout the melody, sonic material is passed between the players that reflect the video projections of the natural exchange of elements. 

Watching the video, the melody is very mystic and abstract. It is actually pretty intense at moments. The melody rises and falls almost like fire. At some points, it is more melodic, at some points ,it’s like random sounds, metal clanging, and mystic signing. Some points actually have lyrics, like “I’m breathing”. You can kind of sense if some parts are more chemical in contrast to parts that seem to reflect nature.

Yoshi Torralva – Project 04 – String-Art


sketch

Using string art, I wanted to create a shell-like formation. I used multiple lines in the for() statement to create a swirling visual. Mouse tracking was implemented to add depth as it served as a frame into the shell.

// Yoshi Torralva
// Section E
// yrt@andrew.cmu.edu
// Project 04
function setup() {
    createCanvas(300, 400);
}

function draw() {
    background(0, 191, 255);
    /* for loop making 40 lines
    which allows for 10px spacing */
    for(var i = 0; i < 40; i++) {
    /* mouseX and Mouse Y move the string art */
    strokeWeight(1);
    stroke(255);
    //moving string art
    line(mouseX, i * 10, 0 + i * 10, mouseY);
    // flipped mouseX and mouse Y to create opposite scaling
    line(mouseY, i * 10, 0 + i * 10, mouseX);
    strokeWeight(0.2);
    //string art starting at top x height 
    // 10 px width between each line
    // increments of 50
    line(i * 10, 0, 300, 0 + i * 10);
    line(i * 10, 0, 250, 0 + i * 10);
    line(i * 10, 0, 200, 0 + i * 10);
    line(i * 10, 0, 150, 0 + i * 10);
    line(i * 10, 0, 100, 0 + i * 10);
    line(i * 10, 0, 50, 0 + i * 10);
    //string art at bottom x height
    // 10 px width between each line
    // increments of 50
    line(250, i * 10, 0 + i * 10, 400);
    line(200, i * 10, 0 + i * 10, 400);
    line(150, i * 10, 0 + i * 10, 400);
    line(100, i * 10, 0 + i * 10, 400);
    line(50, i * 10, 0 + i * 10, 400);
    }
}
 

Jamie Park – Project 04 – String Art

sketch

//Jamie Park           jiminp@andrew.cmu.edu
//15-104          Section E        Project 4

function setup(){
    createCanvas(400, 300);
}

function draw(){
    background(0);

    //random number variable to assign value for colors and coordinate location
    var x = 100;
    var y = 170;
    var z = 50;

    //variable newX and newY to constrain mouseX and mouseY movement to the canvas
    var newX;
    newX = constrain(mouseX, 0, width);
    var newY;
    newY = constrain(mouseY, 0, height);

    //lines for the string art -- are color & mouse location-sensitive
    for (var i = 0; i < width; i+= 8){

        stroke(mouseY, mouseX, x); //central 2 curves that go from top to bottom
        strokeWeight(0.5);
        line(i, newX, newX, i);
        line(i, newY, y, i);

        stroke(mouseX, y, mouseY); //central 3 curves that go from left to right
        line(newX, i, i, z);
        line(i, newY, newX, i);
        line(i, y, newY, i);

        stroke(z, mouseY, mouseX); //bottom left corner lines that overlap
        line(y * 5, i, i, newX);
        line(i, newY, x * 5, i);

        stroke(mouseX, x, y); //top left corner lines that overlap
        line(-x, i, i, newY);
        line(newX, i, i, newX);

        stroke(z, y, mouseY); //very central subtle curve
        line(newY, i, i, y * 2);

        stroke(mouseX, mouseX, y); //top right coner line
        line(i, newX, newY, i);

        stroke(mouseX, mouseY, mouseY); //very left stroke that goes across the width of the canvas
        line(x, i, i, newY);
    }
}

Initially, I was a bit confused with how I should be coding this project. But I became confident after visiting Office Hours and talking to my friends. I added some fun to my code by manipulating colors and location of the curves based on mouseX and mouseY.

Jamie Park – Looking Outwards – 04

Video of Weather Thingy on its official website

Adrien Kaeser demonstrating Weather Thingy (2018)

Weather Thingy, 2018, by Adrien Kaeser

Weather Thingy (2018) is a controller that builds sound using real time climate-related events. The device, composed of weather station on a tripod microphone and a custom built controller, transforms climatic data into midi data, which is then interpreted by programmed instruments. The user can also manipulate the midi channel to modify the effects. The most significant part of Weather Thingy is that it is updated live. When you watch the demo video of the device, wind, sunlight and water have different impacts on the music, creating a unique melody that could not be heard on any other time of the day.

According to the author of the post, the device is coded with Arduino, C++, and midi protocol. Although I have no experience using the three languages, I am thrilled to know that one can use coding to generate sound. Overall, I think it was very creative of Kaeser to convert weather data into melody. It must have been a lot of work and effort with a proper understanding of music, and I admire Kaeser for it.