mluria-final

/*  Submitted by: Michal Luria
    Section A: 9:00AM - 10:20AM
    mluria@andrew.cmu.edu
    Final-Project
*/

//variables to draw circles
var circles = []; //array of circle objects
var sentArray = []; //array for sentences
var posX = []; //the circle bases (character) X array
var posY = []; //the circle bases (character) Y array

//variables to determine most dominant character
var scores = []; //start with an empty array 
var currentHighest = 0; //currently most sentences
var winnerIndex; //the index of the winner
var previousWinnerIndex = -1; //the index of the previous winner 

function preload() {
    //load text to strings - each part (by character) is a string
    textArray = loadStrings('https://courses.ideate.cmu.edu/15-104/f2016/wp-content/uploads/2016/12/the-miser.txt'); 

}

function setup () {

    createCanvas(700,500);
    frameRate(30);

    //determine initial positions of characters
    posX = [width/2, width/5, width/5*4, width/2, width/2, width/5, width/5*4]; 
    posY = [height/2, height/2, height/2, height/5, height/5*4, height/5*4, height/5];

    //initialize 0 for all scores
    for (var k = 0; k < posX.length; k++){

        scores[k] = 0;

    }

    //for every paragraph in the file (one string), split into sentences
    for (var i = 0; i < textArray.length; i++){ 

        //split sentences whenever one of the following chars appear: ;!?.
        sentArray = splitTokens(textArray[i], ";!?.");


        //The following code will do this: for every sentence a character says, create a circle object and draw it

        //if VAL is talking (if the word VAL in the string)
        if (textArray[i].indexOf("VAL") >= 0) {

            //for every sentence VAL speaks, push a circle object into the circle array
            for (var j = 1; j < sentArray.length; j++) {

                /*pass the following variables for each circle object: 
                                        name
                                        length of sentence (the size of the circle is determined by how long the sentence is)
                                        Start frame - each circle has a frame number on which it can start drawing (using FrameCount)
                                                      The start frame is influenced by the index of the play sentences (how far is
                                                      the sentence into the play [i]), by the current index [j], and by the
                                                      length of the previous sentence, in order to give a feel of the play dynamics
                                        Color
                                        Index number
                                        */
                circles.push(new Circle("VAL", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(247, 132, 163, 80), 0));
            }   

        }

        //The above comments are true for each one of the characters in the play below:

        //if ELI is talking (found in string)
        if (textArray[i].indexOf("ELI") >= 0) {

            //for every sentence ELI speaks, push a circle onject into array
            for (var j = 1; j < sentArray.length; j++) {

                circles.push(new Circle("ELI", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(132, 247, 159, 80), 1));
            }

        }

        //if CLE is talking (found in string)
        if (textArray[i].indexOf("CLE") >= 0) {

            //for every sentence CLE speaks, push a circle onject into array
            for (var j = 1; j < sentArray.length; j++) {

                circles.push(new Circle("CLE", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(132, 194, 247, 80), 2));
            }

        }

        //if HAR is talking (found in string)
        if (textArray[i].indexOf("HAR") >= 0) {

            //for every sentence HAR speaks, push a circle onject into array
            for (var j = 1; j < sentArray.length; j++) {

                circles.push(new Circle("HAR", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(255, 246, 100, 80), 3));
            }

        }

        //if LA FL is talking (found in string)
        if (textArray[i].indexOf("LA FL") >= 0) {

            //for every sentence LA FL speaks, push a circle onject into array
            for (var j = 1; j < sentArray.length; j++) {

                circles.push(new Circle("LA FL", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(205, 139, 255, 80), 4));
            }

        }


        //if SIM is talking (found in string)
        if (textArray[i].indexOf("SIM") >= 0) {

            //for every sentence SIM speaks, push a circle onject into array
            for (var j = 1; j < sentArray.length; j++) {

                circles.push(new Circle("SIM", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(133, 251, 255, 80), 5));
            }

        }

        //if FRO is talking (found in string)
        if (textArray[i].indexOf("FRO") >= 0) {

            //for every sentence FRO speaks, push a circle onject into array
            for (var j = 1; j < sentArray.length; j++) {

                circles.push(new Circle("FRO", sentArray[j].length, 
                                        j*i*20+(sentArray[j-1].length*2), color(255, 133, 255, 80), 6));
            }

        }

    }

}


function draw () {

    background(0);
    stroke(0);

    //draw all circle objects
    for (var i = 0; i < circles.length; i++){

        circles[i].draw();

    }

    //The follow section checks who the most dominant character (winner) is and updates their location

    //check all the scores all the time (score = number of sentences a character said)
    for (var j = 0; j < scores.length; j++){

        //if a score is higher the current highest score
        if (scores[j] > currentHighest) {

            currentHighest = scores[j]; //update highest score

            if (j != winnerIndex) { //if the highest score holder (character) changed

                previousWinnerIndex = winnerIndex; //update the previous winner category
                winnerIndex = j; //and update the new winner

            }


        }
    }

    /*Update the winner's location
    The following parts check where the winner is, and move them towards the center
    In parallel, the previous winner is moved in the opposite direction of the winner
    in order to switch between their locations */


    if (posX[winnerIndex] < width/2) {
        posX[winnerIndex]++; 
        posX[previousWinnerIndex]--; 
    }


    if (posY[winnerIndex] < height/2) {
        posY[winnerIndex]++;
        posY[previousWinnerIndex]--;
    }

    if (posX[winnerIndex] > width/2) {
        posX[winnerIndex]--;
        posX[previousWinnerIndex]++;
    }

    if (posY[winnerIndex] > height/2){
        posY[winnerIndex]--;
        posY[previousWinner]++;
    }

}

//define circle object: name, sentence array, start frame, color and index
function Circle(name, sentArray, 
     myStartFrame, circColor, index) {

    this.name = name; //name of actor
    this.sent = sentArray; //length of sentence
    this.index = index; // index of character
    this.x = posX[this.index]; //circle X location
    this.y = posY[this.index]; //circle Y location
    this.siz = 0; //circle Size
    this.start = myStartFrame; //the frame to start drawing the circle
    this.color = circColor; //the color of the circle
 

    this.draw = function() { //draw a circle

        noStroke();


  
        fill(this.color); //use the object's circle

        /*determine circle size by sentence length (as long as the size is smaller than the sentence length * 2.5)
        and only if the current frame count is bigger than the object's start frame
        draw the circle*/
        if (this.siz < this.sent * 2.5 & frameCount > this.start) {
            
            this.x = posX[this.index]; //update the x position according to winner check
            this.y = posY[this.index]; //update the y position according to winner check
            ellipse (this.x, this.y, this.siz, this.siz); //draw the circle
            this.siz++; //increase circle size
            scores[this.index]++; //increase the score count for the character for each of his/her sentence circle 

            //write the name of the character below (also shows up and disappears according to the character on stage)
            textSize(10); 
            text(this.name, this.index*100+40, height-50);

        } 

    }

}

The Miser / Moliere

In my final project I wanted to do data visualization. With a background in theater, I thought it would be interesting to look at plays and show new aspects by using their data.

I used the famous play “The Miser” by Moliere, and created several aspects that would allow viewers to get a sense of the play dynamics.

Description of what you see: 

1. Each circle is a sentence in the play.
2. The size of the circle represents the sentence length.
3. The circle sequence is according to the chronological order of sentences in the play.
4. The interval between sentences is in proportion to the length of the previous sentence.
5. The most dominant character in each part of the play is centered in location.

My final project visualized each sentence by a character in the play using a circle, “played” in the order of the characters text. The size of each circle visualizes the length of the sentence. The project also presents who is on stage at every given moment, and finally, the character that is most dominant in the play comes to the center of the stage.

I hope that using these aspects, it will be easy to get a sense of the pace of the play, if the dialog is quick or slow, who talks a lot and who is more quiet, when monologs occur, and who dominates the play dynamics. I hope that the visualization will allow looking at a famous masterpiece in a new light.

This week I will present two different projects that present famous media (movies and books) in an unexpected way that reveals new and fascinating aspects of the well know work.

TextArc / Bradford Paley

The project of TextArc takes famous books and analyzes their text and content, presenting them a new and interactive way:

All the sentences in the book are presented clockwise, and in the middle the words most frequently used are presented. Furthermore, each word is located in the area it is mentioned the most, for example “Queen is near the end of the book”. When the user hovers a specific word, they can see in what parts of the book this word is used:

Photographs of Films / Jason Shulman

In this project, the artist condensed whole well known classic films into a single frame. Shulman used an algorithm to create the mood and style of the film in a single frame:

In both projects, famous media are taken and presented in a new way that shows aspects that were hidden before, allowing others to look at a piece from a different point of view.

The projects differ in the medium they use – TextArc uses text, as opposed to visual compositions in the films project. Furthermore, TextArc is an interactive program that encourages the user to look into the text, explore, look what words are used and where, etc. The second project, although not interactive, has an advantage of creating a mood that represents a full length movie just by looking at a still image. This resembles more of a work of art, rather than interactive text presentation.

As my final project suggestion is looking at plays from different eras in a new way by visualizing structure aspects, I think both of these projects can inspire my work. I can look at what aspects of the work are presented and what are some ways in which they can be computed and visualized.

For my final project I would like to create a data visualization project of plays. My idea is to look at famous plays in new ways, by presenting various aspects of their structure. I will use the actual text of the play to generate data, and then present it in ways that only consider the structure, not the content. I hope this will present the characteristics of an era or genre, regardless of the play content.

Since all plays are based on character dialog, I would like to show who is on “stage” at every given movement. To represent the dialog itself, each character would have a “circle generator” on the canvas (image below). Each time a character would say a sentence, a circle will be generated, and will expand slowly until faded.

Since the project requires analyzing real texts, a large portion of the challenge would be to convert the text into data that can be used for a visualization project.

This visualization would allow overviewing a play in fast forward mode, and to show the dialog dynamics between characters, their relationship and dominance, and what character is on stage the most or least.

According to complexity and time limitations, a few more ideas on how the project can evolve are:

1. Compare two plays from different eras and allow viewing how their structure varies in parallel.
2. Have the character that speaks the most centered – the least a character talks, the further they are to the edge.
3. Adapt the circle generator to create circles that stay on screen according to their length.

Attached is a sketch of how the screen might look like, while “playing” the play in fast forward:

mluria-11

/*  Submitted by: Michal Luria
    Section A: 9:00AM - 10:20AM
    mluria@andrew.cmu.edu
    Assignment-11-Project
*/

var originalImage;
var px = 0;
var py = 0;
var currentColor;
var pBrightness;

function preload() {
    var myImageURL = "http://i.imgur.com/cU9Kpic.jpg"; //image link
    originalImage = loadImage(myImageURL); //load image
}

function setup() {
    createCanvas(500, 667); 
    background(255);
    originalImage.loadPixels(); //load pixels

}

function draw() {


    //create new turtle
    var turtle = makeTurtle(px, py);

    //settings for turtle
    turtle.setColor(0);
    turtle.setWeight(4);


    while (px < width) { //check first line

        currentColor = originalImage.get(px,py); //fetch color of photo

        if (isColor(currentColor)) { //check that it is a color
            pBrightness = brightness(currentColor); //what is the brightness
        }

        if (pBrightness < 50) { //if the brightness is less than 50 

            //draw a short black line
            turtle.goto(px,py); 
            turtle.penDown();
            turtle.forward(6);
            turtle.penUp();

        }

        px +=6; //adjust px location

    }

    py += 4; //move to next line
    px = 0; //start over on the x axis

}

//check the get function fetched the color
function isColor(c) {
    return (c instanceof Array);
}

//---Turtle Code---//

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, drawPent: turtle};
return turtle;}

This week for my project I wanted to use a turtle to create a graphics project that would look different using a turtle than other methods. I decided to compute a “cartoon” version, a solid black and white picture, from a regular photo. Using this method, the photo can be recreated by computing it in slightly different ways – each small variation would create a very different and new composition from the same source. Furthermore, I liked how any photo can be uploaded into the code and by only changing the photo link – instantly create a new image. The one presented is the version that appealed most to me.

Thru-You / Kutiman

The project I will discuss this week is “Thru-You”, by Israeli musician Kutiman. The project is a song and video clip created by the artist by sampling many unrelated videos that were uploaded to YouTube:

The clip created in the project “Thru-you”, that was created by Kutiman, who samples various clips and created a new musical piece. Source.

Kutiman sampled various clips uploaded to YouTube of artists, musicians and teachers playing different instruments and different melodies.

What I liked most about this project is that instead of creating a musical piece and deciding the role of each instrument in the composition, Kutiman was limited to the clips he found on YouTube and wanted to use, but was also inspired by them.

Kutiman used computational tool to synchronize and match various parts of different songs to work together according to a specific beat, as well as to resample a specific part of a clip to create the wanted result. Although some of the process was manually edited by Kutiman, a lot of his work is based on computing music samples, and ultimately these tools, as well as the existence of the internet, allowed him to create a unique song that is a mashup of videos of random people who posted their videos online.

mluria-10

/*  Submitted by: Michal Luria
    Section A: 9:00AM - 10:20AM
    mluria@andrew.cmu.edu
    Assignment-10-Project
*/

var x = []; //circle X
var y = []; //circle Y
var circSize = []; //size
var circHue = []; //hue
var myParticles = []; //particles
var nParticles = 700;

function setup() {
    createCanvas(600,400); 

    //build an initial array of particles
    for (var i = 0; i < nParticles; i++) {
        var rx = random(width);
        var ry = random(height);
        myParticles[i] = makeParticle(rx, ry, 0, 0);
    }

    //set color to HSB
    colorMode(HSB, 100);
    frameRate(20);

}


function draw() {

    background(0);
    fill(255);
    noStroke();

    
    push();

    //draw particles according to gravity and repulsion forces
    //the first part of the code implements the particle code we learned in class

    var gravityForcex = 0;
    var gravityForcey = 0.05;
    var mutualRepulsionAmount = 2.5;
 
 
    for (var i = 0; i < myParticles.length; i++) {
        var ithParticle = myParticles[i];
        var px = ithParticle.px;
        var py = ithParticle.py;
 
        if (mouseIsPressed) {
            ithParticle.addForce(gravityForcex, gravityForcey);
        }
 
        for (var j = 0; j < i; j++) {
            var jthParticle = myParticles[j];
            var qx = jthParticle.px;
            var qy = jthParticle.py;
 
            var dx = px - qx;
            var dy = py - qy;
            var dh = sqrt(dx * dx + dy * dy);

            if (dh > 1.0) {
                var componentInX = dx / dh;
                var componentInY = dy / dh;
                var proportionToDistanceSquared = 1.0 / (dh * dh);
                var repulsionForcex = mutualRepulsionAmount *
                    componentInX * proportionToDistanceSquared;
                var repulsionForcey = mutualRepulsionAmount *
                    componentInY * proportionToDistanceSquared;
                // add in forces
                ithParticle.addForce( repulsionForcex,  repulsionForcey);
                jthParticle.addForce(-repulsionForcex, -repulsionForcey);
            }
        }
    }
 
    for (var i = 0; i < myParticles.length; i++) {
        myParticles[i].bPeriodicBoundaries = false;
        myParticles[i].bElasticBoundaries = true;
        myParticles[i].update(); // update all locations
    }
 
    for (var i = 0; i < myParticles.length; i++) {
        myParticles[i].draw(); // draw all particles
    }

    //----=====end of particle code=====-----//

    pop();

    //set the likelihood of a circle showing up
    var newCircleLikelihood = 0.3;
    if (random (0,1) < newCircleLikelihood){
        //if new circle is created, push a random location, size and hue
        x.push(random(0, width));
        y.push(random(0, height)); 
        circSize.push(random(0,2));
        circHue.push(random(0,100));
    }
    
    //for the circle array length
    for (var i = 0; i < x.length; i++) {
        var ex = x[i]; //set new x
        var ey = y[i];  //set new y
        var eCirc = circSize[i]; //set new circle size
        var eHue = circHue[i]; //set new hue
        fill(eHue, 100, 100); 

        //every 5 circles draw a moving triangle instead
        if (i % 5 == 0){
            triangle(ex, ey, ex+random(-20,20), ey, ex+(random(-20,20)), ey-random(-20,20));

        //if not triangle, draw circle
        } else {
            ellipse(ex,ey, eCirc, eCirc);  //draw the new circle
        }

        circSize[i] += random(0,3); //make the circle grow in side

        //code to move the circle slightly out of the center
        if (x[i] > width/2) { //if on the left side - move left
            x[i]+=3 ;
        } else { //if on the right side - move right
            x[i]-=3 ;
        }

        if (y[i] > height/2) { //if the circle is on the bottom half
            y[i]++ ; //move down
        } else { //if on the top half
            y[i]-- ; //move up
        }

        if (circSize[i] > height) { //if the circle is too big

            x[i] += 1500; //move it to the side
            y[i] += 1500;
        }
    }


}


// Implementation of partical code with variation
//Mutual repulsion, with optional gravity

// Update the position based on force and velocity
function particleUpdate() {
    if (this.bFixed == false) {
        this.vx *= this.damping;
        this.vy *= this.damping;
  
        this.limitVelocities();
        this.handleBoundaries();
        this.px += this.vx;
        this.py += this.vy;
    }
}


// Prevent particle velocity from exceeding maxSpeed
function particleLimitVelocities() {
    if (this.bLimitVelocities) {
        var speed = sqrt(this.vx * this.vx + this.vy * this.vy);
        var maxSpeed = 10;
        if (speed > maxSpeed) {
            this.vx *= maxSpeed / speed;
            this.vy *= maxSpeed / speed;
        }
    }
}


// do boundary processing if enabled
function particleHandleBoundaries() {
    if (this.bPeriodicBoundaries) {
        if (this.px > width) this.px -= width;
        if (this.px < 0) this.px += width;
        if (this.py > height) this.py -= height;
        if (this.py < 0) this.py += height;
    } else if (this.bHardBoundaries) {
        if (this.px >= width) {
            this.vx = -abs(this.vx);
        }
        if (this.px <= 0) {
            this.vx = abs(this.vx);
        }
        if (this.py >= height) {
            this.vy = -abs(this.vy);
        }
        if (this.py <= 0) {
            this.vy = abs(this.vy);
        }
    }
}


// draw the particle as a white circle
function particleDraw() {
    fill(255);
    noStroke();
    ellipse(this.px, this.py, 2, 2);
}


// add a force to the particle using F = mA
function particleAddForce(fx, fy) {
    var ax = fx / this.mass;
    var ay = fy / this.mass;
    this.vx += ax;
    this.vy += ay;
}


// make a new particle
function makeParticle(x, y, dx, dy) {
    var p = {px: x, py: y, vx: dx, vy: dy,
             mass: 1.0, damping: 0.9,
             bFixed: false,
             bLimitVelocities: false,
             bPeriodicBoundaries: false,
             bHardBoundaries: false,
             addForce: particleAddForce,
             update: particleUpdate,
             limitVelocities: particleLimitVelocities,
             handleBoundaries: particleHandleBoundaries,
             draw: particleDraw
            }
    return p;
}
  



 

For the landscape project this week, I wanted to create a project that would give the sense of outer space, with shapes flying your way. In order to do this, I used different shapes in different sizes and colors, and tried to code their movement to seem to move in your direction. In order to make it more interesting, I also added shape shifting triangles.

For the background of the project, I used the particle code we learned in class, because I liked the way it shifts slowly, similar to how we would see movement of something that is very far away.

Attached is a sketch of my initial idea on paper:

3D printed fashion with sensors / Anouk Wipprecht

The project I will present this week is a project by Anouk Wipprecht. Anouk combines fashion with computation, and uses both new fabrication technologies (laser cutting and 3D printing) and electronics and sensors.

Anouk Wipprecht designing a fashion collection inspired by cars. source

Fashion has been repetitive for quite a long while. Although new trends are introduced each season, they are always adapted from some previous decade. What I like about this project is that Anouk suggests a new way of thinking about fashion and presents a new direction that gives an idea of what fashion of the future might look like, and what it can bring along with it.

Fashion is a way to express ourselves, and why not use extraordinary ways to do so? In her project, Anouk embeds car sensors and lights to create a new type of interaction with a wearable prototype. The dress reacts to the person’s surrounding and to others who approach them. The final prototype resulted in a both a novel way in which people can express themselves, as well as a new way to interact with other people around us, using the wearable technology we own.

mluria-09

/*  Submitted by: Michal Luria
    Section A: 9:00AM - 10:20AM
    mluria@andrew.cmu.edu
    Assignment-09-Project
*/

var originalImage;

function preload() {
    var myImageURL = "http://i.imgur.com/vUZZk6h.jpg"; //image link
    originalImage = loadImage(myImageURL); //load image
}

function setup() {
    createCanvas(500, 500); 
    background(0);
    originalImage.loadPixels(); //load pixels
    frameRate(20000);
}

function draw() {

    for (var i = 0; i < 500; i ++){ //draw 500 pixels each frame

        var px = random(width); //draw a line in a random x
        var py = random(height); //draw a line in a random y
        var ix = constrain(floor(px), -20, width-1); //constrain x
        var iy = constrain(floor(py), -20, height-1); //contrain y
        var theColorAtLocationXY = originalImage.get(ix, iy); //what is the color at a specific location

        var curveX1 = random(1,15); //start of curve (X)
        var curveX2 = curveX1 + random(1,15); //second point - same direction(X)
        var curveX3 = curveX2 + random(1,15); //third point - same direction (X)

        var curveY1 = random(1,15); //start of curve (Y)
        var curveY2 = curveY1 + random(1,15); //second point - same direction(Y)
        var curveY3 = curveY2 + random(1,15); //third point - same direcation(Y)

        var strokeSize = random(1,3); //stroke weight random

        strokeWeight(strokeSize);
        stroke(theColorAtLocationXY); //stroke in the color of pixel

        curve(px, py, px+curveX1, py+curveY1, px+curveX2, py+curveY2, px+curveX3, py+curveY3); //draw curve

    }

}

In this portrait I wanted to create a feeling of a drawn portrait. To do this, I created random sized curves, in different angles, but all drawn to the same direction to create an artistic style. This is inspired by artists in the impressionist movement. The different sized curves create a sense of brushstrokes, and end up in an image that is not completely clear, but gives a sense of the portrait mood.

Kinematic Dress / N-e-r-v-o-u-s System (2014)

source

Looking Outwards 03 by sajohnso

I was fascinated by the project of a 3D printed dress that is aimed to be flexible, and that would allow movement and would lay comfortably on the body, like other garments, rather than hard 3D printed wearable “sculptures” that were previously designed using 3D printed techniques.

I agree with the Looking Outwards post in that the most interesting aspect of this project is not in the dress itself,  but the sophisticated printing method – the dress was simulated being folded on a computer and was printed in a folded “chunk of a dress”. This allowed to print it in one piece, rather than hand assembly small parts.

I would like to extend on how this is important for the advancement of 3D printed garments. In my opinion, the ability to “fold” parts on the computer and only then print it allows easy home fabrication in one click. Anybody can create this kind of item, since assembly is not required. This indeed places us one step closer to a DIY fashion revolution, as sajohnso posted on this project.

Kyle McDonald

The artist I will present for this weekly assignment is Kyle McDonald. McDonald works on the intersection between artificial intelligence and art, and creates tools to allow artists to apply machine learning to their work. He is a professor at NYU ITP and a artist in residence at CMU.

What I like about his work is that McDonald focuses on understanding artificial intelligence, and does this by placing it in contrast to human intelligence, asking questions about its meaning, how is it different from human intelligence, and where it might lead to in the future.

Some of the interesting aspects Kyle explores in his work are the biases AI currently has, for example, by asking “who isn’t in the training data?”, as well as looking at patterns of AI and playing around with what various data sets can result in.

McDonald’s work combines exploration of AI – what is it capable of doing and how can you leverage it to create art, along with thoughts on the results, problems and philosophical questions this developing technology creates.

Kyle McDonald talking about AI in his talk “Weird Intelligence”, as part of the Eyeo annual conference. source.