Sonica

Sonica is a dynamic generative artwork that replicates the notion and ideas raised by Alvin Lucier’s, ‘I Am Sitting in a Room.’ This 1969 voice performance consisted of the repetition and iteration of the single sentence slowly becoming muddled until the tones of the voice became a series of frequencies. Lucier’s decision to isolate the voice inevitably stripped back ego and identity and so reduced the artwork to simple forms of sound and echo within this sonic environment.  This artwork became my inspiration as I too intended to represent just the echo and sounds of voice.

I achieved this by appropriating the work of Michael Pinn (http://www.openprocessing.org/sketch/208059) to understand the workings of a ripple. From here, I altered the code allowing me to fully understand different functions that I hadn’t previously practiced.  I was comfortable within the confines of iteration of a loop within a grid. I wanted to escape this confine and work with an iteration in individual shapes. This has been an interesting learning experience as I realized that keeping it simple created an aesthetic appeal—much like Lucier’s work—whilst too experimenting with code and shape to replicate and iterate a form that is invisible to the naked eyesound and echo.

Screenshot of the code within Processing
Screenshot of the code within Processing
The dynamic sketch in motion
The dynamic sketch in motion
The line ripples around the centre at 90 radians
The line ripples around the centre at 90 radians
The iteration of the four loop
The iteration of the four loop
All ellipses and lines are reduced to a stroke weighht of 1 after the for loop
All ellipses and lines are reduced to a stroke weight of 1 after the for loop.

THE CODE AND ANNOTATIONS:

void setup() {

//sets up the basis for the code and the

//dimensions and properties the code will be performed in.

size(840, 840);

//creates a large enough space to view the code.

noFill();

//the shape created will not be filled with a colour but left blank, this puts

//and emphasis on just the stroke and the way that it moves.

stroke(225, 255, 100);

//defines the colour of the stroke

//noLoop();

//the for loop is continued, meaning that it is not a stationary code.

ellipseMode(CENTER);

//Centers the ellipse rendering the movement of the ellipse so that the whole

//ellipse does not revolve around the center point but makes a ripple instead.

background(50);

//one integer used for the background sets it on a grey scale

//if three colours were used, it would specify with red, green, blue.

}

void draw() {

//sets up the code to draw until the code is stopped.

translate(width/2, height/2);

//this centers the shapes(unless later specified after) within the middle of the

//window(width and height specified initially in size). This means that even

//if the window size changed, the location of each ‘x’ and ‘y’ coordinate

//would not be altered individually as the function moves the shapes accordingly.

//It is divided by ‘2’ to ensure that is exactly half the x and y axis.

for (int i = 90; i < 360; i+=30) {

//the for loop begins with at 90 (pi) meaning that it is 90 radians away from

//the center.

//i<360 as it defines the properties of each line/ripple as it is a

//full revolution (2 pi) allowing the for loop to start again at the initial position

//of 90.

float angle = sin(radians(i/4-frameCount*8))*16;

//float is used when there are decimal places involved. In this case,

//using sin means that information about the degree of the angle is given in

//radians up to 2 pi–implying that there are decimals.

//”i” is divided by 4 to create a slower rippling effect. The lower the

//number means that the sin curve is repeated less within the same time span.

//The details of each ripple is shown with a lower number (4)

//When the frame count is multiplied by a larger number,

//the speed of the frames are sped up.

//The whole expression is multiplied by 15 to increase the scope.

if (angle > 1) {

strokeWeight(angle);

//Whilst completing the four loop, if the angle is larger than one,

//the stroke weight will reflect the angle specified.

//the stroke weight is the density of the stroke.

} else {

//Once the four loop has looped enough times

strokeWeight(1);

//the four loop resorts to its basic stroke Weight of 1.

}

pushMatrix();

//this function allows for the coordinates of the stroke weight to be saved and

//tracked. This allows for the for loop to perform, whilst saving the

//stroke weight creating a ripple effect–the lasting effect.

rotate(radians(i*angle/150));

//the angle needs to be specified in radians as it determines the angle of

//rotation. This angle multiplied by “i” allows for the ripples to rotate

//around the 90 radians that was specified earlier and allows it to

//complete a full revolution (2 pi)

ellipse(0, 0, i, i);

//this ellipse is set with a position that is centre according to the earlier

//ellipseMODE.

//”i” is used as the x and y coordinate as these change due to the angle and

//the four loop that is performed where the ripples alter the size.

ellipse(100,100, i*10, i*10);

stroke(200, 225,150);

//the ellipse’s size is multiplied by 10 thus making it bigger than the

//window. The center of the ellipse is also to 100 for both x and y

//offset the centrality of the first ellipse.

//the stroke is also given a colour within the red, blue, green matrix.

line (200,200,i*20,i*20);

//A line is created and is multiplied by 20

//to change the scale of the ripples as it rotates around the

//previously determined

//(50) radians.

line (-200,-200,i*20,i*20);

stroke(225,225,225);

//a line is created opposite the previous line using (-) to place the

//rotation on the opposite side of the unit circle.

fill(30,30, 30, 30);

//this fill is placed at the end as it only impacts the strokes of the two

//lines and the two ellipse. A fourth number is added to the red, blue, green

//matrix to create a transparency.

popMatrix();

//the ripple effect –lasting effect– is restored to its original stroke weight

//of 1 so that when the for loop is completed again the ripple is still

//seen and is not just iterating the same loop on top, adding to the stroke

//weight. thus creating a fluid movement and not a build up.

}

}

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s