Author: breep

breep-arsculpture

For my arscultpure I made a snake altar that comes out of a toilet to embody childhood fears. My project stemmed from an irrational fear I had as a child where I was afraid that a snake would come up the toilet as I sat on it. Through this the sense of threat of the toilet snakes only become apparent when the body is present, so I made the snake head appear out of nowhere when the viewer gets closer to highlight the unexpected nature of this hypothetical event. I had a fair amount of trouble with the scaling and placing of my sculpture so I placed an ideal scenario image underneath which is what I had initially envisioned for this piece.

 

 

 

 

breep-book

URL  Link to to Zip file:

https://drive.google.com/open?id=1mXvIeBIjU3qrf3-heWDO1dSfpWrZdWjk

Title: The Hands of Gutenberg

Chapter Description: A series of sonnets with first lines containing the word 'hand' generated from the Gutenberg Poetry corpus overlaid on images of multispectral palmprints. (EDIT: I later notices the that the hand lines have moved down the sonnet as the poems progress)

Using the Gutenberg Poetry corpus as my starting point, I wanted to explore ways to generate or find Iambic pentameters. The primary basis for this was that I wanted my final poems to make some semblance of rhyming sense, using the stress structure of the Iambic pentameter to act as a platform in assisting this.

Taking the some 3 millions lines of poetry in the corpus, I created two programs: One to filter out all the Iambic Pentameters that had the word 'Hand' in it (taking primary inspiration for this from a dataset of handprint images that I wanted to use), and another to filter out all the Iambic Pentameters. I discovered that there were only 18 lines that possessed the word hand, nowhere near enough to use to generate all my poems as I initially intended. Instead, I decided to use these lines as the starting lines for 18 poems, creating a structure of starting point that could connect all 25 iterations of the chapter (a notion I was a big fan of).

From this I started to find rhymes for these lines in the larger Iambic line corpus I had found, and again was woefully short of lines. From this I decided to create the structure of randomly finding a line with the body of Iambics and swapping out the last word (which I filtered out with matching structure (noun, adjective etc) with the line before to make the replacement more sensible) with a word that rhymed with the line before and had the Iambic stress structure. From this I had to use RiTa to find rhymes for the lines, from which I ran into a snag of rhyming with plurals (which made rhyming but not grammatical sense) which I sorted by removing the final 's' on each one (it also didn't like old english use of apostrophes, for example walk'd, which I largely also swapped out for e) . With this all completed, I had 18 pairs of lines which I felt could be extended, hence the continuation to 14 lines in the structure of a sonnet using another 6 random line pairings found from the corpus. With these generated, I then had to create a program to filter these collections into JSON files to be used for the generative layouts.

With this completed, I started to sort through all the and images, and divided them into left and right facing hands, and using this divide randomly generated hand pairings for the pages of the book such that the thumbs faced toward the spine and the space left above them could be used to place the text within.

Overall, I had initially intended to use an image set as a starting point but found that for the sake of poetic sense I should use the text. Having generated the Iambics, I sorted through image sets at hand to determine what pairings between image and text could be made, and thus the connection between the hands came about.

I am particularly happy with the outcome, especially the extent to which the poetic license of the sonnets is pushed. However, I feel that this could definitely be taken further, where instead of randomly finding new lines to fill in the sonnets, I would filter the Iambics for their content and generate poems whose lines connected more with the content they possessed. Through this, my swapping of final words to rhymes could also be greater filtered in connection to the line it is being swapped into to ensure more sense as well.

 

 

Finding Iambics with Hand (Initially in P5Js):

 
var data; 
 
function preload(){
	data = loadStrings("finger.txt")
}
 
function setup() {
  createCanvas(400, 400);
  final = createIambs(); 
  print(final); 
}
 
function createIambs() {
  var stressList = []; 
 
  var finalIambs = [];
 
  for (var i = 0; i < data.length; i++){
    currentStress = RiTa.getStresses(data[i]); 
    currentStress = currentStress.replace("/", " "); 
    currentStress = currentStress.replace(" , ", " "); 
    currentStress = currentStress.replace("1/0", "1 0"); 
    currentStress = currentStress.replace("1/1", "1 1"); 
    currentStress = currentStress.replace("0/1", "0 1"); 
    stressList.push(currentStress); 
    if (currentStress == "0 1 0 1 0 1 0 1 0 1"){
      finalIambs.push(data[i]); 
    }
}
  return finalIambs; 
}

Sonnet Builder (Processing):

 
import rita.*;
String startLines[];
String buildLines[]; 
PrintWriter outputter;
String[] finalWords = new String[18]; 
 
String[] testerRhymes = new String[20]; 
 
String[][] dictionary = new String[18][15]; 
 
String[] finalPairings = new String[18]; 
 
void setup(){
 
  startLines = loadStrings("handIambs.txt");
  buildLines = loadStrings("gutenbergIambics.txt"); 
 
  outputter = createWriter("data/finalPoems.txt");
 
  int numberStartLines = startLines.length;
  int numberBuildLines = buildLines.length; 
 
 
  for (int i = 0; i < numberStartLines; i++){
    String currentStartLine = startLines[i]; 
 
    String[] dataRows = currentStartLine.split(" ");
 
    String finalWord = dataRows[dataRows.length-1]; 
 
    finalWords[i] = finalWord; 
 
    String[] rhymes = RiTa.rhymes(finalWord); 
 
    String currentType = ""; 
 
    if (RiTa.isNoun(finalWord)){
      currentType = "Noun";
    }
 
    if (RiTa.isVerb(finalWord)){
      currentType = "Verb";
    }
 
    if (RiTa.isAdjective(finalWord)){
      currentType = "Adjective";
    }
 
    if (RiTa.isAdverb(finalWord)){
      currentType = "Adverb";
    }
 
    String currentStress = RiTa.getStresses(finalWord); 
 
    //for (int k = 0; k < rhymes.length; k ++){
 
    int k = 0; 
    while ( k < rhymes.length){
      String currentRhyme = rhymes[k]; 
 
      String currentRhymeType = ""; 
 
      if (RiTa.isNoun(finalWord)){
        currentRhymeType = "Noun";
        }
 
      if (RiTa.isVerb(finalWord)){
        currentRhymeType = "Verb";
        }
 
      if (RiTa.isAdjective(finalWord)){
        currentRhymeType = "Adjective";
        }
 
      if (RiTa.isAdverb(finalWord)){
        currentRhymeType = "Adverb";
        }
 
      String currentRhymeStress = RiTa.getStresses(currentRhyme);  
 
      if (currentRhymeType != currentType){
        rhymes = concat(subset(rhymes, 0, k-1), subset(rhymes, k+1, rhymes.length-1 - k)); 
        }
 
      /*if (currentStress != currentRhymeStress){
        rhymes = concat(subset(rhymes, 0, k-1), subset(rhymes, k+1, rhymes.length-1 - k)); 
      }*/
 
      k += 1; 
    }
    //print(rhymes); 
 
    Boolean wordFound = false; 
 
    while (wordFound == false){
      int randomIndex = floor(random(405)); 
 
      String currentRandomLine = buildLines[randomIndex]; 
 
      String[] randomLine = currentRandomLine.split(" ");
 
      String randomFinalWord = randomLine[randomLine.length-1]; 
 
      String currentRhymeType = "";
 
      if (RiTa.isNoun(randomFinalWord)){
        currentRhymeType = "Noun";
        }
 
      if (RiTa.isVerb(randomFinalWord)){
        currentRhymeType = "Verb";
        }
 
      if (RiTa.isAdjective(randomFinalWord)){
        currentRhymeType = "Adjective";
        }
 
      if (RiTa.isAdverb(randomFinalWord)){
        currentRhymeType = "Adverb";
        }
 
      if (currentRhymeType == currentType){
        String randomRhyme = rhymes[floor(random(rhymes.length))]; 
 
 
        randomLine[randomLine.length-1] = randomRhyme; 
 
        print(randomLine); 
 
        wordFound = true; 
      }
 
      finalPairings[i] = currentStartLine + "\n" + randomLine;  
 
    }
 
  }
  }
 
 
 
 
 
void draw(){
}

JSON Builder (Processing):

 
JSONArray json;
 
String[] lines; 
 
JSONObject[] jsonList = new JSONObject[20]; 
 
 
void setup() {
 
  for (int a = 0; a < 25; a++){
 
  lines = loadStrings("testingFinalSonnets" + a + ".txt");
 
  json = new JSONArray(); 
 
  for (int i=0; i < 20; i++){
 
    JSONObject currentSonnet = new JSONObject(); 
 
    if (i == 0){
      currentSonnet.setInt("Id", 0); 
      currentSonnet.setString("text", "The Hands of Gutenberg");
      json.setJSONObject(i, currentSonnet);
      continue;
      }
 
    if (i == 19){
      currentSonnet.setInt("Id", 19); 
      currentSonnet.setString("text", "");
      json.setJSONObject(i, currentSonnet);
      continue;
      }
 
 
    String currentString = join(subset(lines, i*14, 14), "\n"); 
 
    currentSonnet.setInt("Id", i);
    currentSonnet.setString("text", currentString); 
 
 
    json.setJSONObject(i, currentSonnet);
 
   }
 
   saveJSONArray(json, "data/finalSonnets" + a + ".json");
  }
}

Generative Layout (Processing) (Starter Code courtesy of Golan Levin):

 
// Export a multi-page PDF alphabet book. 
 
import processing.pdf.*;
boolean bExportingPDF;  
// See https://processing.org/reference/libraries/pdf/index.html
 
int nPages; 
PImage imageArray[];
JSONArray jsonPages;
int outputPageCount = 0; 
 
PFont highQualityFont32;
PFont highQualityFont100;
float inch = 72; 
 
String pdfName; 
 
//=======================================================
void setup() {
 
  // The book format is 6" x 9". 
  // Each inch is 72 pixels (or points). 
  // 6x72=432, 9*72=648 
 
  // USE THESE COMMANDS WHEN YOU'RE NOT EXPORTING PDF, 
  // AND YOU JUST WANT SCREEN DISPLAY:
  //size(432, 648); 
  bExportingPDF = false;
 
   size(432, 648, PDF, "24-breep.pdf");
   bExportingPDF = true;
 
  int m = 24; 
 
 
    if (m / 10 == 0){
      pdfName = "0" + m + "-breep.pdf";
      }
 
    else{
      pdfName = m + "-breep.pdf";
    }
 
    //size(432, 648, PDF, "00-breep.pdf");
    //bExportingPDF = true;
 
    //--------------------
    // For high-quality (vector) typography:
    // See https://processing.org/reference/libraries/pdf/index.html
    // "Another option for type, is to use createFont() with a TrueType font 
    // (some OpenType fonts also work). Any font that shows up in PFont.list() 
    // should work, or if not, adding a .ttf file to the data directory 
    // and calling createFont("fontname.ttf") will also work.
 
    highQualityFont32 = createFont("vag.ttf", 32);
    highQualityFont100 = createFont("vag.ttf", 100);
 
    jsonPages = loadJSONArray("text/finalSonnets" + m + ".json");
    nPages = jsonPages.size(); 
 
    // Load the images from the data folder,
    // Using the filenames from the JSON array. 
 
    imageArray = new PImage[nPages];
 
    for (int i=0; i<nPages; i++) {
      JSONObject aPage = jsonPages.getJSONObject(i);
      int currentHand = (i + 1) + (m*10); 
 
      String imageFileName = ""; 
 
      if (i % 2 == 0){
        imageFileName = "images/joint/" + "rightHand" + currentHand + ".jpg"; 
      }
      else{
        imageFileName = "images/joint/" + "leftHand" + currentHand + ".jpg";
      }
 
      imageArray[i] = loadImage(imageFileName);
    }
}
 
//=======================================================
void draw() {
  if (bExportingPDF) {
    drawForPDFOutput();
  } else {
    drawForScreenOutput();
  }
}
 
//=======================================================
void drawForPDFOutput() {
 
  // When finished drawing, quit and save the file
  if (outputPageCount >= nPages) {
    exit();
  } else {
    drawPage(outputPageCount); 
    PGraphicsPDF pdf = (PGraphicsPDF) g;  // Get the renderer
    if (outputPageCount < (nPages-1)) {
      pdf.nextPage();  // Tell it to go to the next page
    }
  }
 
  outputPageCount++;
}
 
 
//=======================================================
void drawForScreenOutput() {
  int whichPageIndex = (int) map(mouseX, 0, width, 0, nPages);
  drawPage(whichPageIndex);
}
 
 
 
//=======================================================
void drawPage(int whichPageIndex) {
  background(255);
  whichPageIndex = constrain(whichPageIndex, 0, nPages-1); 
  JSONObject whichPageObject = jsonPages.getJSONObject(whichPageIndex); 
 
  // Fetch and render image
  PImage whichImage = imageArray[whichPageIndex];
  float imgWRaw = whichImage.width; 
  float imgHRaw = whichImage.height;
  float imgW = max(imgWRaw, width*0.85);
  float imgScale = imgW/imgWRaw;
  float imgH = imgHRaw* imgScale;
  float imgX = (width - imgW)/2.0;
  float imgY = height - imgH - inch*1.5;
  image(whichImage, 0, 0, width, height); 
 
 
  // Assemble body text
  String captionString = whichPageObject.getString("text"); 
 
 
  // Display body text
  textFont(highQualityFont32);
  fill(255); 
  textAlign(CENTER); 
  textSize(15); 
  if (whichPageIndex % 2 == 0){
    text(captionString, (width/3) + 20, height/10);
    }
  else{
    text(captionString, ((width/3) * 2) - 20, height/10);
    }
}

breep-parrish

I feel that the concept that stuck with me the most in watching the lecture was Parrish's conception of Nonsense. This element of challenging the human brain to dissect that which is has never been spoken before, or indeed is at all inhospitable to human reading/taking in, was a striking new way to look at poetry. In some respects, poetry for me is making that which is more subconscious more accessible to the reader, so to subvert this function for the sake of unique iterations and indeed images within the content I found was a powerful lesson in the power of the fragile nature of language.

breep-harsh-Automaton

(Turn Up Audio, also detail videos of each individual unit further down post)

Taking heavy inspiration from Banksy's pet shop, we wanted to explore connections between machines and human bodies and particularly the ways both could be exploited. Through that we landed on the idea of torture, which fundamentally seeks to expose weakness in whatever it is inflicted upon. With this in mine we started to brainstorm individual units that we wanted to put together into one larger body to convey different aspects of torture (psychological, physical etc). This gave way to the three separate parts that we have in our final product, each influenced in its execution by objects we found at the centre for creative re-use that we felt could be exploited through the use of machinery and as a stand-ins for machinery itself.

The aesthetics of the end result was much more dependant on the tools/construction and frameworks of torture rather than the items from the centre for creative re-use, which lends itself to the unity of the separate parts. The clarity of the cassette tape component definitely needs work in terms of making apparent the action there, with the integration of the IR sensor also proving difficult for this specific component.

A large part of the computation as well as the preparation for construction was done by Harsh, given his knowledge in both Arduino and Physical Computing, with the eye and dunking unit primarily handled by him. More of the construction was done by Breep, as well as the most part of the Casette unit.

breep – LookingOutwards04

Rain Room is an installation by the artist group Random International in which rain falls from the ceiling and the presence of the human body stops the rain from falling. The simplicity of the concept and flawless execution really attracted me to this piece. Not only does it explore the materiality of the natural world, it explores our relationship through it in this absurd subversion of the roles. I feel this kind of work is especially curious in the context of present day environmental concerns, being that the work employs the natural subjugation of a natural process (rain) while also seemingly appearing unnatural in its minimalistic setting of the indoor gallery. The work employs all our senses, the smell of the water just as much a body of the work as the lack of water on the body is. It explores man's relationship with machine and nature simultaneously, extracting the essence of natural processes out of its machinations.

 

 

breep-Body

 

For this piece the motion definitely came first. I most experimented with ways of conveying the body through lines while getting to know Mocap in Processing, the video underneath is one of the more refined outcomes of my experimentation. With my series of experimentations in place, I thought through each and wanted to build a form of narrative in which this digital body wills itself into existence from an initial form as a plane. From this I came to the final piece, which moves toward the viewer just as the walking motion does, urging itself onwards into existence as the viewer scrolls through.

I am mildly pleased with the outcome, but not happy. I feel that greater blending between the states with more steps would make this a more cohesive transition.

 

 

 
// Based off of Template provided on 60212 Fall 2018 Website
 
 
// Renders a BVH file with Processing v3.4
// Note: mouseX controls the camera.
// Based off of com.rhizomatiks.bvh
// Golan Levin, September 2018
 
 
 
PBvh myBrekelBvh;
PBvh secondBrekelBvh; 
PBvh thirdBrekelBvh;
PBvh fourthBrekelBvh; 
PBvh fifthBrekelBvh; 
boolean bDrawMeat = true; 
boolean bDrawLineConnectingHands = false; 
boolean bDrawCircleAtOrigin = false; 
boolean bDrawLineToBoneInScreenspace = false; 
float boneScreenX; 
float boneScreenY; 
int xCamera = 500; 
int yCamera = 500; 
int zCamera = 500; 
int distance = 3200; 
int distanceFinal = 4000; 
int distanceWalkout = 4400; 
 
//------------------------------------------------
void setup() {
  size( 1280, 720, P3D );
  // Load a BVH file recorded with a Kinect v2, made in Brekel Pro Body v2.
  myBrekelBvh = new PBvh( loadStrings("walk_bold.bvh" ) );
 
  secondBrekelBvh = new PBvh( loadStrings("walk-cycle.bvh") ); 
 
}
 
 
//------------------------------------------------
void draw() {
  lights() ;
  background(0, 0, 0);
 
  pushMatrix(); 
  setMyCamera();        // Position the camera. See code below.
  //drawMyGround();       // Draw the ground. See code below.
  updateAndDrawBody();  // Update and render the BVH file. See code below.
  popMatrix(); 
 
  drawHelpInfo();
  drawLineToHead();
 
 
}
 
void keyPressed() {
  switch (key) {
  case 'M': 
  case 'm': 
    bDrawMeat = !bDrawMeat; 
    break;
  case 'L':
  case 'l': 
    bDrawLineConnectingHands = !bDrawLineConnectingHands;
    break;
  case 'O': 
  case 'o': 
    bDrawCircleAtOrigin = !bDrawCircleAtOrigin; 
    break;
  case 'H': 
  case 'h':
    bDrawLineToBoneInScreenspace = !bDrawLineToBoneInScreenspace; 
    break;
 
  case 'w': 
    yCamera += 50; 
    break; 
  case 's':
    yCamera -= 50; 
    break; 
  case 'd':
    xCamera += 50; 
    break; 
  case 'a':
    xCamera -= 50; 
    break; 
 
  case 'f':
    zCamera += 50; 
    break; 
  case 'g':
    zCamera -= 50; 
    break; 
 
  }
}
 
 
//------------------------------------------------
void updateAndDrawBody() {
 
  pushMatrix(); 
  translate(width/2, height/2, 0); // position the body in space
  scale(-1, -1, 1); // correct for the coordinate system orientation
  myBrekelBvh.update(millis()); // update the BVH playback
 
  pushMatrix();
  stroke(255, 0, 0); 
  //myBrekelBvh.draw();        // one way to draw the BVH file (see PBvh.pde)
  popMatrix(); 
 
 
  if (bDrawMeat) {
    myBrekelBvh.drawBones(); // a different way to draw the BVH file
  }
 
  if (bDrawLineConnectingHands) {
    drawLineConnectingHands();
  }
 
  if (bDrawCircleAtOrigin) {
    drawCircleAtOrigin();
  }
 
  if (bDrawLineToBoneInScreenspace) {
    myBrekelBvh.calculateScreenspaceLocationOfBone("Head");
  }
 
  popMatrix();
 
 
  pushMatrix(); 
  translate(width/2, height/2, 0); // position the body in space
  scale(-1, -1, 1); // correct for the coordinate system orientation
  myBrekelBvh.update(millis()); // update the BVH playback
 
  pushMatrix();
  stroke(255, 0, 0); 
  //myBrekelBvh.draw();        // one way to draw the BVH file (see PBvh.pde)
  popMatrix(); 
 
 
  if (bDrawMeat) {
    secondBrekelBvh.drawBones(); // a different way to draw the BVH file
  }
 
  if (bDrawLineConnectingHands) {
    drawLineConnectingHands();
  }
 
  if (bDrawCircleAtOrigin) {
    drawCircleAtOrigin();
  }
 
  if (bDrawLineToBoneInScreenspace) {
    secondBrekelBvh.calculateScreenspaceLocationOfBone("Head");
  }
 
  popMatrix();
 
}
 
//------------------------------------------------
 
void drawHelpInfo() {
  fill(255); 
  float ty = 20; 
  float dy = 15; 
  //text("BVH Loader for Processing 3.4", 20, ty+=dy);
  //text("Displays files recorded with Kinect v2 + Brekel Pro Body 2", 20, ty+=dy);
 
  //text("", 20, ty+=dy);
  //text("Press 'M' to toggle meat", 20, ty+=dy);
  //text("Press 'L' to draw line connecting hands", 20, ty+=dy);
  //text("Press 'O' to draw circle at Origin", 20, ty+=dy);
  //text("Press 'H' to draw line from mouse to Head", 20, ty+=dy);
}
 
 
//------------------------------------------------
 
void drawLineToHead() {
  if (bDrawLineToBoneInScreenspace) {
    stroke(0, 255, 255); 
    strokeWeight(3); 
    line (mouseX, mouseY, boneScreenX, boneScreenY);
  }
}
 
 
//------------------------------------------------
 
void drawCircleAtOrigin() {
  fill(255); 
  stroke(255, 0, 0); 
  strokeWeight(4); 
  ellipse(0, 0, 20, 20);
}
 
 
//------------------------------------------------
void drawLineConnectingHands() {
  // This example code shows how to reach into the skeleton 
  // in order to get specific joint locations (in 3D)
 
  PVector[] boneLocationsFirst = new PVector[19]; 
  PVector[] boneLocationsSecond = new PVector[19]; 
 
  for (int i = 0; i < 19; i ++){
    int currentIndex = i; 
    BvhBone currentBoneFirst = myBrekelBvh.parser.getBones().get(currentIndex); 
    PVector currentBonePosFirst = currentBoneFirst.absPos;
 
    BvhBone currentBoneSecond = secondBrekelBvh.parser.getBones().get(currentIndex); 
    PVector currentBonePosSecond = currentBoneSecond.absPos;
 
    boneLocationsFirst[i] = currentBonePosFirst;
    boneLocationsSecond[i] = currentBonePosSecond; 
  }
 
 
  for (int j = 0; j < 19; j ++){
      for (int z = 0; z < 19; z ++){ 
      PVector currentPosFirst = boneLocationsFirst[j]; 
      PVector secondPosFirst = boneLocationsFirst[z]; 
 
      PVector currentPosSecond = boneLocationsSecond[j];
      PVector secondPosSecond = boneLocationsSecond[z]; 
 
      stroke(255, 255, 255); 
      strokeWeight(1); 
 
      // Body Lines 
 
      pushMatrix(); 
 
      if (j == 1) {
        for (int a = 1; a < 4; a ++){
        line( 7 * boneLocationsFirst[a].x, 7 * boneLocationsFirst[a].y, boneLocationsFirst[a].z + distance, 
             7 * boneLocationsFirst[a+1].x, 7 *boneLocationsFirst[a+1].y, boneLocationsFirst[a+1].z + distance);
        }
      } 
 
      if (j == 5) { 
        line( 7 * boneLocationsFirst[3].x, 7 * boneLocationsFirst[3].y, boneLocationsFirst[3].z + distance, 
             7 * boneLocationsFirst[5].x, 7 * boneLocationsFirst[5].y, boneLocationsFirst[5].z + distance);
 
        for (int b = 5; b < 8; b ++){
        line( 7 * boneLocationsFirst[b].x, 7 * boneLocationsFirst[b].y, boneLocationsFirst[b].z + distance, 
             7 * boneLocationsFirst[b+1].x, 7 * boneLocationsFirst[b+1].y, boneLocationsFirst[b+1].z + distance);
        }
      }
 
      if (j == 9) { 
        line( 7 * boneLocationsFirst[3].x, 7 * boneLocationsFirst[3].y, boneLocationsFirst[3].z + distance, 
             7 * boneLocationsFirst[9].x, 7 *boneLocationsFirst[9].y, boneLocationsFirst[9].z + distance);
 
        for (int c = 9; c < 12; c ++){
        line( 7 * boneLocationsFirst[c].x, 7 * boneLocationsFirst[c].y, boneLocationsFirst[c].z + distance, 
             7 * boneLocationsFirst[c+1].x, 7 *boneLocationsFirst[c+1].y, boneLocationsFirst[c+1].z + distance);
        }
      }
 
      if (j == 13) { 
        line( 7 * boneLocationsFirst[1].x, 7 * boneLocationsFirst[1].y, boneLocationsFirst[1].z + distance, 
             7 * boneLocationsFirst[13].x, 7 *boneLocationsFirst[13].y, boneLocationsFirst[13].z + distance);
 
        for (int d = 13; d < 15; d ++){
        line( 7 * boneLocationsFirst[d].x, 7 * boneLocationsFirst[d].y, boneLocationsFirst[d].z + distance, 
             7 * boneLocationsFirst[d+1].x, 7 *boneLocationsFirst[d+1].y, boneLocationsFirst[d+1].z + distance);
        }
      }
 
      if (j == 16) { 
        line( 7 * boneLocationsFirst[1].x, 7 * boneLocationsFirst[1].y, boneLocationsFirst[1].z + distance, 
             7 * boneLocationsFirst[16].x, 7 *boneLocationsFirst[16].y, boneLocationsFirst[16].z + distance);
 
        for (int e = 16; e < 18; e ++){
        line( 7 * boneLocationsFirst[e].x, 7 * boneLocationsFirst[e].y, boneLocationsFirst[e].z + distance, 
             7 * boneLocationsFirst[e+1].x, 7 *boneLocationsFirst[e+1].y, boneLocationsFirst[e+1].z + distance);
        }
      }
 
      /* translate(0, 0, distance); 
      ellipse(7 * boneLocationsFirst[4].x, 7 * boneLocationsFirst[4].y + 30, 20, 20); */ 
 
      popMatrix(); 
 
      ////----------------------
 
      pushMatrix(); 
 
      if (j == 1) {
        for (int a = 1; a < 4; a ++){
        line( 8 * boneLocationsFirst[a].x, 8 * boneLocationsFirst[a].y, boneLocationsFirst[a].z + distanceFinal, 
             8 * boneLocationsFirst[a+1].x, 8 *boneLocationsFirst[a+1].y, boneLocationsFirst[a+1].z + distanceFinal);
        }
      } 
 
      if (j == 5) { 
        line( 8 * boneLocationsFirst[3].x, 8 * boneLocationsFirst[3].y, boneLocationsFirst[3].z + distanceFinal, 
             8 * boneLocationsFirst[5].x, 8 * boneLocationsFirst[5].y, boneLocationsFirst[5].z + distanceFinal);
 
        for (int b = 5; b < 8; b ++){
        line( 8 * boneLocationsFirst[b].x, 8 * boneLocationsFirst[b].y, boneLocationsFirst[b].z + distanceFinal, 
             8 * boneLocationsFirst[b+1].x, 8 * boneLocationsFirst[b+1].y, boneLocationsFirst[b+1].z + distanceFinal);
        }
      }
 
      if (j == 9) { 
        line( 8 * boneLocationsFirst[3].x, 8 * boneLocationsFirst[3].y, boneLocationsFirst[3].z + distanceFinal, 
             8 * boneLocationsFirst[9].x, 8 *boneLocationsFirst[9].y, boneLocationsFirst[9].z + distanceFinal);
 
        for (int c = 9; c < 12; c ++){
        line( 8 * boneLocationsFirst[c].x, 8 * boneLocationsFirst[c].y, boneLocationsFirst[c].z + distanceFinal, 
             8 * boneLocationsFirst[c+1].x, 8 *boneLocationsFirst[c+1].y, boneLocationsFirst[c+1].z + distanceFinal);
        }
      }
 
      if (j == 13) { 
        line( 8 * boneLocationsFirst[1].x, 8 * boneLocationsFirst[1].y, boneLocationsFirst[1].z + distanceFinal, 
             8 * boneLocationsFirst[13].x, 8 *boneLocationsFirst[13].y, boneLocationsFirst[13].z + distanceFinal);
 
        for (int d = 13; d < 15; d ++){
        line( 8 * boneLocationsFirst[d].x, 8 * boneLocationsFirst[d].y, boneLocationsFirst[d].z + distanceFinal, 
             8 * boneLocationsFirst[d+1].x, 8 *boneLocationsFirst[d+1].y, boneLocationsFirst[d+1].z + distanceFinal);
        }
      }
 
      if (j == 16) { 
        line( 8 * boneLocationsFirst[1].x, 8 * boneLocationsFirst[1].y, boneLocationsFirst[1].z + distanceFinal, 
             8 * boneLocationsFirst[16].x, 8 *boneLocationsFirst[16].y, boneLocationsFirst[16].z + distanceFinal);
 
        for (int e = 16; e < 18; e ++){
        line( 8 * boneLocationsFirst[e].x, 8 * boneLocationsFirst[e].y, boneLocationsFirst[e].z + distanceFinal, 
             8 * boneLocationsFirst[e+1].x, 8 *boneLocationsFirst[e+1].y, boneLocationsFirst[e+1].z + distanceFinal);
        }
      }
 
      /* translate(0, 0, distance); 
      ellipse(7 * boneLocationsFirst[4].x, 7 * boneLocationsFirst[4].y + 30, 20, 20); */ 
 
      popMatrix(); 
 
 
      // Points of body to backside origin  
 
      pushMatrix(); 
           translate(0, 0, 2400); 
            line( 6 * currentPosFirst.x, 6 * currentPosFirst.y, currentPosFirst.z, 
                  0, 0 , -400); 
            popMatrix(); 
 
 
       // Points of body to backside origin  
 
      pushMatrix(); 
           translate(0, 0, 3200); 
            line( 6 * currentPosFirst.x, 6 * currentPosFirst.y, currentPosFirst.z, 
                  0, 0 , -400); 
            popMatrix(); 
 
 
       //BaseLine
       pushMatrix(); 
          stroke(255); 
          line(
            currentPosFirst.x + 10000, currentPosFirst.y, currentPosFirst.z - 400,
            currentPosSecond.x - 10000, currentPosSecond.y, currentPosSecond.z - 400); 
          popMatrix();
 
 
       //Lines extrapolating to one direction
          pushMatrix(); 
          stroke(255); 
          line(
            currentPosFirst.x + 10, currentPosFirst.y, currentPosFirst.z,
            currentPosFirst.x - 10, currentPosFirst.y, currentPosFirst.z); 
          popMatrix();
 
 
       /* //Lines extrapolating to one direction
          pushMatrix(); 
          stroke(255); 
          line(
            currentPosFirst.x + 50, currentPosFirst.y, currentPosFirst.z + 100,
            currentPosFirst.x - 50, currentPosFirst.y, currentPosFirst.z + 100); 
          popMatrix();
 
       //Lines extrapolating to one direction
          pushMatrix(); 
          stroke(255); 
          line(
            currentPosFirst.x + 25, currentPosFirst.y, currentPosFirst.z + 200,
            currentPosFirst.x - 25, currentPosFirst.y, currentPosFirst.z + 200); 
          popMatrix();
 
 
      //Lines extrapolating to one direction
          pushMatrix(); 
          stroke(255); 
          line(
            currentPosFirst.x + 10, currentPosFirst.y, currentPosFirst.z + 300,
            currentPosFirst.x - 10, currentPosFirst.y, currentPosFirst.z + 300); 
          popMatrix();*/ 
 
 
      //Lines in First Body
 
      line(
        2 * currentPosFirst.x, 2 * currentPosFirst.y, currentPosFirst.z + 400,
        2 * secondPosFirst.z, 2 * secondPosFirst.y, secondPosFirst.z + 400);
 
 
      for (int k = 0; k < 8; k ++){
 
          //Tutu
 
          float angle = map(k, 0, 8, 0, TWO_PI); 
 
          /*if (k % 2 == 0){
          stroke(255, 0, 0);}
 
          else{
          stroke(0, 0, 255);}*/
 
          stroke(255); 
 
          line(
            3 * currentPosFirst.x, 3 * currentPosFirst.y, currentPosFirst.z + 800,
            100 * cos(angle), 50, 100 * sin(angle) + 800); 
 
          /*line(
            5 * currentPosSecond.x, 5 * currentPosSecond.y, currentPosSecond.z, 
            100 * cos(angle), 50, 100 * sin(angle));*/
 
          pushMatrix(); 
 
          /*if (k % 2 == 0){
          stroke(0, 255, 0);}
 
          else{
          stroke(255, 0, 0);}*/ 
 
          stroke(255); 
 
          line(
            4 * currentPosFirst.x, 4 * currentPosFirst.y, currentPosFirst.z + 1600,
            100 * sin(angle), (100 * cos(angle)), 100 * cos(angle) + 1200); 
 
          popMatrix(); 
 
 
 
          /*pushMatrix(); 
          translate(0, 0, 1200); 
          stroke(255, 0, 0); 
          ellipse(4 * currentPosFirst.x, 4 * currentPosFirst.y, 10, 10); 
          popMatrix();*/ 
 
          /*pushMatrix(); 
          translate(0, 0, 2000); 
          stroke(255); 
          ellipse(5 * currentPosFirst.x, 5 * currentPosFirst.y, 5, 5); 
          popMatrix(); */
 
          /*pushMatrix(); 
          translate(0, 0, 2000); 
          stroke(255, 0, 0); 
          ellipse(6 * currentPosFirst.x, 6 * currentPosFirst.y, 50, 50); 
          popMatrix(); 
 
          pushMatrix(); 
          translate(0, 0, 2000); 
          stroke(255, 0, 0); 
          ellipse(6 * currentPosFirst.x, 6 * currentPosFirst.y, 100, 100); 
          popMatrix(); */ 
 
 
          /*pushMatrix(); 
          stroke(255); 
          line(
            4 * currentPosFirst.x, 4 * currentPosFirst.y, currentPosFirst.z + 600,
            5 * currentPosFirst.x, 5 * currentPosFirst.y, currentPosFirst.z + 1000); 
          translate(0,0, 10000); 
          ellipse(currentPosFirst.x, currentPosFirst.y, 50, 50); 
          popMatrix(); */ 
      } 
      }
      }
  }
 
 
          /*pushMatrix(); 
 
          if (k % 2 == 0){
          stroke(0, 255, 0);}
 
          else{
          stroke(255, 0, 0);}
 
          line(
            currentPosFirst.x, currentPosFirst.y, currentPosFirst.z ,
            100 * sin(angle), (100 * sin(angle)) + (100 * cos(angle)), 100 * cos(angle)); 
 
          popMatrix();*/ 
 
 
 
          //Lines extrapolating to one direction to Origin
          /*pushMatrix(); 
          if (k == 0){
            stroke(0, 255, 0);}
          else if (k == 1){
            stroke(255, 0, 0);}
          else {
            stroke(0, 0, 255);}
          translate(-(60*k), 0, 0); 
          line(
            currentPosSecond.x + (60 * k), currentPosSecond.y, currentPosSecond.z,
            0, 200, 200); 
          popMatrix(); */
 
 
 
 
//------------------------------------------------
void setMyCamera() {
 
 
  // Adjust the position of the camera
  float eyeX = 650;          // x-coordinate for the eye
  float eyeY = yCamera; //height/2.0f - 200;   // y-coordinate for the eye
  float eyeZ = mouseY * 8;             // z-coordinate for the eye
  float centerX = width/2.0f;   // x-coordinate for the center of the scene
  float centerY = height/2.0f;  // y-coordinate for the center of the scene
  float centerZ = -400;         // z-coordinate for the center of the scene
  float upX = 0;                // usually 0.0, 1.0, or -1.0
  float upY = 1;                // usually 0.0, 1.0, or -1.0
  float upZ = 0;                // usually 0.0, 1.0, or -1.0
 
  camera(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
 
}
 
//------------------------------------------------
void drawMyGround() {
  // Draw a grid in the center of the ground 
  pushMatrix(); 
  translate(width/2, height/2, 0); // position the body in space
  scale(-1, -1, 1);
 
  stroke(100);
  strokeWeight(1); 
 
  float gridSize = 400; 
  int nGridDivisions = 10; 
 
  for (int col=0; col<=nGridDivisions; col++) {
    float x = map(col, 0, nGridDivisions, -gridSize, gridSize);
    line (x, 0, -gridSize, x, 0, gridSize);
  }
  for (int row=0; row<=nGridDivisions; row++) {
    float z = map(row, 0, nGridDivisions, -gridSize, gridSize); 
    line (-gridSize, 0, z, gridSize, 0, z);
  }
 
  popMatrix();
}

 

 

breep-telematic

Glitch App: Ensure Audio is on (Headphones are optimum for the notion of privacy) 

To log in:

  1. Do Not Click anywhere on the screen or press any keys
  2. Click on Username Input Box
  3. Enter Username
  4. Click on Password Input Box
  5. Enter Password
  6. Press Enter, and you should enter into the chatroom
  7. If nothing happens, refresh the page and try again

Documentation:

All messages received are spoken out to the user with p5.js Speech, and the only hallmark of them within the chat is 'Received Message'. However all text sent to the chat is posted on twitter with the username associated as well as the text and a hashtag. There is no evidence on the group chat of this occurring though, so the allure of privacy is maintained.

Twitter Page

I would like to view this project as a public private chat. I learnt a-lot about TwitterBots in the process of making this piece, as well as html and the connection between servers and clients. I struggled a-lot with implementing libraries initially, with my understanding of where the code should fit into the glitch page. I am happy with the text part of the project, but I feel that more work on the speech element of it would aid in making it seem more polished. I would also dedicate more time to make the chatroom itself more conducive to the audio formatting.

I feel the piece is many to many, given that the population of the chatroom speaks to the population of twitter. It is asynchronous given the disjunction inherent within communication. Everyone has equal roles, there is no special communicator within the chat room. I feel the piece is both anonymous and intimate, given the lack of awareness of the public aspect of it. It is remote collaboration, given that those in chat room would communicate across distance as well as the content on the twitterpage reaching a wider audience. I feel the work is self-reflexive and critical of networked environments, highlighting the faith in privacy on the internet despite the public connections that those stem on.

 

breep-viewing04

Spectacle: Projects made with the intention of impressing the viewer with its surface level ideas/aesthetics, but disregards the technological context of today that leads to the ability to create such projects

Speculation: Projects made with full acknowledgement of the digital process/theory, often critiquing it in a self aware fashion, but disregards the actual practise of creating digital artworks

I decided to highlight Mark Leckey's GreenScreenRefridgeratorAction as to me it is pure spectulation. The work explores the systems inherent in a refrigerator through all the types of style that Alan Warbuton. I highlight also because it was introduced to me in Critical Theory, and I found the disjunction between what I had learnt about the work there in context of Duchamp against the modern technology context of Warburton's video a raw example of the Speculation he talks about.

In my eyes it is very much digital drag, given its simplified commercial like animations and rudimentary use of green-screen. It is much more about visibility, considering both its context as a performance and as a highlighting of the inner mechanisms of this everyday technology system. It weighs more on the surplus side as well, given its over-dissection as a highlighting of what is taken for granted proving worthwhile conceptually rather than wasteful of the technology (which it arguably counteracts). It is most certainly more on the art side, given its strong aesthetic and form inspiration from the artistic technologic context that Warburton describes. I feel that it lies between function and dysfunction, its content highlighting the functionality of things while also dysfunctionally using simplified and overused technology.