Week 9: Abstract over photography

In this week’s workshop, we explore what happens when instructions are used to abstract forms and processes over another medium: photography.

We analyse the work of a few photographers and attempt to break down their work as abstractions expressed in instructions. Again, our primary endeavour is one of abstracting an idea. And this involves 2 things:

  1. Judging what it is that needs to be abstracted; which essential aspect of a photo or the process of taking a photo is responsible for its aesthetic life?
  2. Working out how to capture those essential characteristics into instructions.

For example: observe the below photograph by Bill Henson.

Artist : Bill Henson (Australia, b.1955) Title : Date : 1985-1986 Medium Description: type C photograph Dimensions : Credit Line : Hallmark Cards Australian Photography Collection Fund 1988 Image Credit Line : Accession Number : 70.1988

Artist : Bill Henson (Australia, b.1955)
Date : 1985-1986
Medium Description: type C photograph

Possible abstraction:

Take a photo of an urban context on a bright sunny day. Underexpose the photo so much that it looks like dusk.

‘The Creek’
The Edge, 2013
© Tamara Dean
‘The Edge’ is an exploration of the informal rites of passage created by young people in relationship with the natural world. The initiations, the pushing of physical, spiritual and emotional limits in order to discover one’s sense of self.

Possible abstraction:

In an empty landscape, take a photo of someone walking into a dark bush

Shaun Gladwell

Possible abstraction

Put a human mask on inanimate object. Take a photo of it lying down.  

Exercise 1: To abstract, distil!

Your tutor will provide you with an image by one of two Australian photographers: Jordan Madge and Marcus Andersen. Analyse the image and reduce it to its singular key visual idea. This idea might be:

  • compositional
  • textural
  • spatial
  • tonal
  • etc.

IMPORTANT: Do not try to replicate the photo. Identify the key visual idea, and translate *that* to a 1 sentence instruction.

Once you have written your 1 sentence instruction, swap with another student. Execute each others’ instructions then discuss.

Exercise 2: Choose your own image

Step 1: Explore the photography of these Australian photographers

  • Bill Henson
  • Justien Varga
  • Marcus Andersen
  • Tamara Dean
  • Tracey Moffatt
  • Matthew Abbott
  • Jordan Madge
  • Shaun Gladwell
  • Henri Mallard
  • Michael Riley

Step 2: Choose a single photograph that you think you can abstract into instructions. Write those instructions on a piece of paper.

Step 3: Share those instructions with another student.

Step 4: Document the photos that are the result of the instructions you wrote.

Exercise 3: Analysis

Analyse the below works (some were discussed early on in lectures).

  • Identify the key ‘rule’ that is used to generate each work
  • Research the artists’ intent, describe their thinking
  • How has the presentation of the work augmented the rules defined
  • How do these rules differ from Sol Lewitt’s style rules?
Image result for ed ruscha all blocks on sunset boulevard

Ed Rusha, Every Building on the Sunset Strip (1966)

Image result for Mario Merz Fibonacci 1202

Mario Merz, Fibonacci 1202

 

Image result for Gary Hill’s Conundrum

Gary Hill, Conundrum, 1995

Image result for Mel Bochner’s 36 Photographs and 12 Diagrams

Mel Bochner, 36 Photographs and 12 Diagrams, 1966

Exercise 4: Ad Lib Instructions

Now, invent your own instructions without taking any cues from existing photos. Again, swap with another student, execute and discuss the results.

Examples might be:

  • Take 16 photos that each has a strong horizontal line exactly in the middle of the image. Organise in a 4×4 grid.
  • Take 10 photos, each of a different red car
  • Take a photo of every part of your body that is not clothed
  • Take 10 photos, each separated by a count of minutes defined by the Fibonacci sequence (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …)
  • Take a photo of the face of someone you don’t know
  • Turn your exposure up 3 or 5 stops. Take a photo of a shadow.

Coding (Using Images)

Processing actually makes it very simple to include and manipulate images into your sketch. You might try going through the following tutorial: https://processing.org/tutorials/pixels/

Or play with the following code. Note, you’ll need to put this image on your Desktop first:

https://processing.org/tutorials/pixels/imgs/tint1.jpg

Screen Shot 2015-09-16 at 2.51.56 pm

// this next line loads up the image.
// It is a complicated way of saying "get the image from my desktop".
PImage sunflower = loadImage(System.getProperty("user.home") + "/Desktop/tint1.jpg");
  
void setup(){
  size(500,500);
  noLoop();
}

void draw(){
   tint(255,100); // this makes the image transparent
   for (int i = 0; i < 100 ; i ++) {
     image(sunflower,(int)random(300),(int)random(300));
   }
}

One thought on “Week 9: Abstract over photography

  1. // this next line loads up the image.
    // It is a complicated way of saying “get the image from my desktop”.
    PImage sunflower;
    PImage destination; // Destination image
    int w = 80;
    int pointillize = 16;
    // It’s possible to perform a convolution
    // the image with different matrices

    float[][] matrix = { { -1, -1, -1 },
    { -1, 9, -1 },
    { -1, -1, -1 } };

    void setup(){
    size(400,600);
    //size(200,200);
    // int sunflower;
    String url = “https://processing.org/tutorials/pixels/imgs/tint1.jpg”;
    sunflower= loadImage(url,”jpg”);
    noLoop();
    // destination = createImage(sunflower.width, sunflower.height, RGB);
    // background(0);
    // smooth();
    }

    void draw(){

    changeTint();
    // setPixelsGray();
    // setPixelsLocation();
    // newImage();
    // Thesholding();
    // ThresholdOnly();
    // cascade();
    // sharpenAndConvolve();
    //Pointilism();
    }

    void changeTint(){
    // The image retains its original state.
    tint(255);
    image(sunflower,0,0);
    //The image appears darker.
    tint(100);
    image(sunflower,200,0);
    // The image is at 50% opacity.
    tint(255,127);
    image(sunflower,0,200);
    // None of its red, most of its green, and all of its blue.
    tint(0,200,255);
    image(sunflower,200,200);
    // The image is tinted red and transparent.
    tint(255,0,0,100);
    image(sunflower,0,400);
    // The image is tinted RED AND BLUE and transparent.
    tint(255,0,255,100);
    image(sunflower,200,400);
    }

    void setPixelsGray(){
    // Before we deal with pixels
    loadPixels();
    // Loop through every pixel
    for (int i = 0; i < pixels.length; i++) {
    // Pick a random number, 0 to 255
    float rand = random(255);
    // Create a grayscale color based on random number
    color c = color(rand);
    // Set pixel at that location to random color
    pixels[i] = c;
    }
    // When we are finished dealing with pixels
    updatePixels();
    }

    void setPixelsLocation(){
    loadPixels();
    // Loop through every pixel column
    for (int x = 0; x < width; x++) {
    // Loop through every pixel row
    for (int y = 0; y < height; y++) {
    // Use the formula to find the 1D location
    int loc = x + y * width;
    if (x % 2 == 0) { // If we are an even column
    pixels[loc] = color(255);
    } else { // If we are an odd column
    pixels[loc] = color(0);
    }
    }
    }
    updatePixels();
    }
    void newImage(){
    //PImage img = createImage(320,240,RGB); // Make a PImage object
    //println(img.width); // Yields 320
    //println(img.height); // Yields 240
    //img.pixels[0] = color(255,0,0); // Sets the first pixel of the image to red

    loadPixels();
    // Since we are going to access the image's pixels too
    sunflower.loadPixels();
    for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
    int loc = x + y*width;

    // The functions red(), green(), and blue() pull out the 3 color components from a pixel.
    float r = red(sunflower.pixels[loc]);
    float g = green(sunflower.pixels[loc]);
    float b = blue(sunflower.pixels[loc]);

    // Image Processing would go here
    // If we were to change the RGB values, we would do it here,
    // before setting the pixel in the display window.

    // Set the display pixel to the image pixel
    pixels[loc] = color(r,g,b);
    }
    }
    updatePixels();
    }

    void newTint(){
    for (int x = 0; x < sunflower.width; x++) {
    for (int y = 0; y < sunflower.height; y++ ) {
    // Calculate the 1D pixel location
    int loc = x + y*sunflower.width;
    // Get the R,G,B values from image
    float r = red (sunflower.pixels[loc]);
    float g = green (sunflower.pixels[loc]);
    float b = blue (sunflower.pixels[loc]);
    // Change brightness according to the mouse here
    float adjustBrightness = ((float) mouseX / width) * 8.0;
    r *= adjustBrightness;
    g *= adjustBrightness;
    b *= adjustBrightness;
    // Constrain RGB to between 0-255
    r = constrain(r,0,255);
    g = constrain(g,0,255);
    b = constrain(b,0,255);
    // Make a new color and set pixel in the window
    color c = color(r,g,b);
    pixels[loc] = c;
    }
    }
    }

    void Thesholding(){
    float threshold = 127;
    // We are going to look at both image's pixels
    sunflower.loadPixels();
    destination.loadPixels();

    for (int x = 0; x < sunflower.width; x++) {
    for (int y = 0; y threshold) {
    destination.pixels[loc] = color(255); // White
    } else {
    destination.pixels[loc] = color(0); // Black
    }
    }
    }

    // We changed the pixels in destination
    destination.updatePixels();
    // Display the destination
    image(destination,0,0);
    }

    void ThresholdOnly(){
    // Draw the image
    image(sunflower,0,0);
    // Filter the window with a threshold effect
    // 0.5 means threshold is 50% brightness
    filter(THRESHOLD,0.5);
    }

    void EdgeDetection(){
    // Since we are looking at left neighbors
    // We skip the first column
    for (int x = 1; x < width; x++) {
    for (int y = 0; y < height; y++ ) {
    // Pixel location and color
    int loc = x + y*sunflower.width;
    color pix = sunflower.pixels[loc];

    // Pixel to the left location and color
    int leftLoc = (x-1) + y*sunflower.width;
    color leftPix = sunflower.pixels[leftLoc];

    // New color is difference between pixel and left neighbor
    float diff = abs(brightness(pix) – brightness(leftPix));
    pixels[loc] = color(diff);
    }
    }
    }

    void sharpenAndConvolve(){
    // We're only going to process a portion of the image
    // so let's set the whole image as the background first
    image(sunflower,0,0);
    // Where is the small rectangle we will process
    int xstart = constrain(mouseX-w/2,0,sunflower.width);
    int ystart = constrain(mouseY-w/2,0,sunflower.height);
    int xend = constrain(mouseX+w/2,0,sunflower.width);
    int yend = constrain(mouseY+w/2,0,sunflower.height);
    int matrixsize = 3;
    loadPixels();
    // Begin our loop for every pixel
    for (int x = xstart; x < xend; x++) {
    for (int y = ystart; y < yend; y++ ) {
    // Each pixel location (x,y) gets passed into a function called convolution()
    // which returns a new color value to be displayed.
    color c = convolution(x,y,matrix,matrixsize,sunflower);
    int loc = x + y*sunflower.width;
    pixels[loc] = c;
    }
    }
    updatePixels();

    stroke(0);
    noFill();
    rect(xstart,ystart,w,w);
    }

    color convolution(int x, int y, float[][] matrix, int matrixsize, PImage img) {
    float rtotal = 0.0;
    float gtotal = 0.0;
    float btotal = 0.0;
    int offset = matrixsize / 2;
    // Loop through convolution matrix
    for (int i = 0; i < matrixsize; i++){
    for (int j= 0; j < matrixsize; j++){
    // What pixel are we testing
    int xloc = x+i-offset;
    int yloc = y+j-offset;
    int loc = xloc + img.width*yloc;
    // Make sure we have not walked off the edge of the pixel array
    loc = constrain(loc,0,img.pixels.length-1);
    // Calculate the convolution
    // We sum all the neighboring pixels multiplied by the values in the convolution matrix.
    rtotal += (red(img.pixels[loc]) * matrix[i][j]);
    gtotal += (green(img.pixels[loc]) * matrix[i][j]);
    btotal += (blue(img.pixels[loc]) * matrix[i][j]);
    }
    }
    // Make sure RGB is within range
    rtotal = constrain(rtotal,0,255);
    gtotal = constrain(gtotal,0,255);
    btotal = constrain(btotal,0,255);
    // Return the resulting color
    return color(rtotal,gtotal,btotal);
    }

    void Pointilism(){
    // Pick a random point
    int x = int(random(sunflower.width));
    int y = int(random(sunflower.height));
    int loc = x + y*sunflower.width;

    // Look up the RGB color in the source image
    loadPixels();
    float r = red(sunflower.pixels[loc]);
    float g = green(sunflower.pixels[loc]);
    float b = blue(sunflower.pixels[loc]);
    noStroke();

    // Draw an ellipse at that location with that color
    fill(r,g,b,100);
    ellipse(x,y,pointillize,pointillize);
    }
    void cascade(){
    tint(255,100); // this makes the image transparent
    for (int i = 0; i < 100 ; i ++) {
    image(sunflower,(int)random(300),(int)random(300));
    }
    }

Leave a Reply

Your email address will not be published. Required fields are marked *