Author: Miranda

Adventures of the Solitary Bee, Composed, written, performed and directed by Miya Masaoka. Special thanks to Scot Duration: 8:32 from Miya Masaoka on Vimeo.

The artist that I will be looked into was Miya Masaoka, a composer, sound artist, and musician based in New York City. Her work operates at the intersection of spatialized sound, recording inside physical objects or inside a plant or the human body, within architecturally resonant spaces or outdoor resonant canyons. A specific project that I found resonating was Adventures of the Solitary Bee (1999), where she uses natural sounds in addition to some musical notes made via instruments to create an almost electronic white-noise. The visual imagery and audio used in the video create a strong tie between the natural and man-made, two areas of study the artist has delved into before, but at separate times. Not much is written about the algorithms used to create this sound, but from what I can gather a basic audio editing program that allows overlays probably worked with as it is her raw material that is vital to the project.

sketch

/* Miranda Luong
Section E
mluong@andrew.cmu.edu
Project-11-Composition
*/

var myTurtle

function setup() {
    createCanvas(480, 480);
    background(0);
    myTurtle = makeTurtle(width/2,height/2); //places starting turtle at center
    myTurtle.setColor('black');
    myTurtle.setWeight(6);
}

// When the user clicks the mouse
function mousePressed() {
    //turtle moves to mouse
    myTurtle.goto(mouseX,mouseY);
    //if mouse is south of canvas' horizontal center, pen is red
    if (mouseY > height/2){
      myTurtle.setColor('red');
    }
    //if mouse is north of canvas' horizontal center, pen is blue
    if (mouseY < height/2){
      myTurtle.setColor('blue');
    }
    //size of circle is random from range between 5 and 20
    var size = random(5,20);
    //draw circle
    for (var i = 0; i < 360; i+=size){
        myTurtle.penDown();
        myTurtle.right(size);
        myTurtle.forward(10);
        myTurtle.penUp();
    }
}


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

I went for a pretty simple drawing. When a visitor clicks on the canvas, a circle is drawn. The colors of these circles change according to where they clicked.

sketch

/* Miranda Luong
Section E
mluong@andrew.cmu.edu
Project-10: Generative Landscape
*/
var trees  = [];
var hillSpeed = 0.00005;
var hillDetail = 0.005;

function setup() {
    createCanvas(640, 240); 
    
    // create an initial collection of 30 trees
    for (var i = 0; i < 30; i++){
        //sets random birthplaceX for trees 
        var rx = random(width);
        trees[i] = makeTree(rx);
    }
    frameRate(100);
}


function draw() {
    background(66, 131, 244); 
    //sun
    noStroke();
    fill(225, 145, 90);
    ellipse(width-55, 40, 45, 45);
    drawHill();
    updateAndDisplay();
    removeOutOfView();
    addTrees();

}

function drawHill(){
    noStroke();
    fill('green');
    beginShape();
    vertex(0, height);
    for (var x = 0; x < width; x++){
        var h = (x * hillDetail)+ (millis() * hillSpeed);
        var y = map(noise(h), 0, 1, 0, height);
        vertex(x, y);
    }
    vertex(width,height);
    endShape();
}

function updateAndDisplay(){
    // Update the trees's positions, and display them.
    for (var i = 0; i < trees.length; i++){
        trees[i].move();
        trees[i].display();
    }
}

function removeOutOfView(){
    // If a tree has dropped off the left edge,
    // remove it from the array.  Copy all the buildings
    // we want to keep into a new array.
    var treesToKeep = [];
    for (var i = 0; i < trees.length; i++){
        if (trees[i].x + trees[i].breadth > 0) {
            treesToKeep.push(trees[i]);
        }
    }
    trees = treesToKeep; // remember the surviving buildings
}

function addTrees() {
    // With a very tiny probability, add a new tree to the end.
    var newTreeLikelihood = 0.007; 
    if (random(0,1) < newTreeLikelihood) {
        trees.push(makeTree(width));
    }
}

// method to update position of tree every frame
function treeMove() {
    this.x += this.speed;
}
    
// draw the tree
function treeDisplay() {
    var totalBushHeight = this.nBush * this.bushHeight
    noStroke(); 
    push();
    translate(this.x, height-100);
    for (var i = this.nBush; i > 1; i = i - 1) {
        fill(14, 100-(i*5), 39); 
        triangle(0, i * this.bushHeight, this.breadth, i * this.bushHeight, this.breadth/2, (i-1)*(this.bushHeight-5));
        }
    fill('brown');
    rect(this.breadth / 4 + 2.5,totalBushHeight,5,8)
    pop();
}

function makeTree(birthLocationX) {
    var tree = {x: birthLocationX,
                breadth: 20,
                speed: -1.0,
                nBush: round(random(2,5)),
                move: treeMove,
                display: treeDisplay,
                bushHeight: 10}
    return tree;
}

This was a really challenging exercise. Sadly, there was a lot I wanted to do but just couldn’t seem to figure out. Ideally, the shape of the hills would’ve matched the position of the trees but because the X placement of the trees from the beginning was random, I couldn’t create a linkage by chronological order of birth (a for loop would’ve been great for that).
I think I definitely have a better understanding of objects and creating generative landscape images, a far cry from past projects generative art.

Original Sketch