Month: September 2022

blog 3

Paul Li 
Section A


Arabesque Wall (2014/2015)

This project is very similar to my selection from last week, the Subdivide Column by Michael Hansmeyer. In fact, it was a project by Benjamin Dillenburger in collaboration with Hansmeyer. I just found their work so limitless and inspiring. I think the mixture of the ornamentation that is reminiscent of historical decoration and the sci-fi aspect of the forms and curves really pushes ideas of architectural concepts and forms I’ve been taught. The algorithm behind the creation was based on actual arabesque ornament examples, which are very mathematical and geometric in nature. By dividing and repositioning surfaces, tiles are altered into microscopic to large pieces that are folded and in the end composes a very complex geometry. I also really admire the amount of details of these structures, while being grand in size as well. The artistic aspect of these projects is that there is unlimited potential and every one of them can be adjusted with generative controls that ensures the uniqueness of each piece while being able to reach a certain desirable form.



https://benjamin-dillenburger.com/arabesque-wall/

Looking Outwards-03: Section B

Desbians Design Research is a company dedicated to computational fabrication and design. Of their many projects, I find the Fahz, face in a vase, project fascinating. This project transforms photographs of faces in profile by first converting them into vector coordinates. The coordinates of up to four photos are uploaded into software that generates a unique vase design that incorporates each face. The final piece is 3D printed.

There are four distinct faces in this vase.

The faces are not carved into the vase, but are created in the negative space around the vase. The minimalism and simplicity of this project are at odds with the hyper, overproduced world we live in. The art found in the absence inspires me. Sometimes less really is more.

This project was originated by Daniel Desbians in 2014. He modeled the vases with Rhino 3D design software with an add-on called Grasshopper to aid with creating algorithms. Python was also used to put it all together. Each vase is unique and designed by software from a parametric model. This is an example of generative art fabricated into physical form.

Looking Outwards 03: Computational Fabrication

Braumann J. and S. Brell-Cokcan – ‘Real-Time Robot Simulation and Control for Architectural Design’ (2012)

The project that was really inspirational for me was the ‘real time robot simulation and control for architectural design’. Many factors attracted towards this project, as it was something that was happening in real time and improving lives and the built environment. I really liked the way architects made use of the multifunctional nature of robots, I was not aware that robots had a lower cost than that of actual workers. I was also fascinated by how these tasks were accomplished with pristine accuracy by employing simple algorithms. Using grasshopper to create computational design was something that really fascinated me. The paper/project is targeted towards introducing robots in the field of architecture and how useful they might be when employed correctly, via using algorithms and peeking intuitively. I do not know much about the algorithms that generated these designs or are responsible for computational design in architecture, but I do know that grasshopper is a key
tool in this task, and I have a little experience using grasshopper. Grasshopper has a relatively easy and understandable interface and generates algorithms that in turn projects 3 dimensional computational design of Rhino. The final project is an example of what a computational fabrication environment is able to achieve, thus, a proof of concept and mass customization.

Link

Project 03 – Dynamic Drawing – srauch

Here is my interactive picture! As you move your mouse left to right, it gets dark outside and the moon comes up, and as you move your mouse up and down, the plant grows and its leaves open up.

sketch
//Sam Rauch / srauch / section B
//This code creates an interactive picture of a plant with a window behind it. As you move
//the mouse up and down, it gets darker and lighter outside. As you move the mouse side to
//side, the plant grows bigger and smaller. 

var windowTransparent //alpha for transparency of blue window, ie how light outside
var moonY = 300; //y position of moon
var moonview = 0; //alpha for transparency of moon
var potCenterX; //x center of pot
var potCenterY; //y center of pot
var bluefade = 0; //amount of blue added to colors as it gets darker outside
var colorfade = 0; //amount of color subtracted to colors as it gets darker outside
var plantTipY; //y tip of plant
var stemweight = 10;
var leafSizeX = 50; //width of leaf
var leafSizeY = 25; //height of leaf
var leftRotate; //rotates left-side leaves
var rightRotate; //rotates right-side leaves

var width;
var height;

function setup() {
    createCanvas(450, 600);
    background(220);
    text("p5.js vers 0.9.0 test.", 10, 15);

    width = 450;
    height = 600;
    windowTransparent = 255;
    potCenterX = 200; 
    potCenterY = 500; 
    plantTipY = potCenterY; //start the tip of the plant in the center of the pot

    leftRotate = 270;
    rightRotate = 90;

}

//draws an ellipse where the first two parameters are the ellipse's left tip
function lefttipellipse(tipX, tipY, wide, tall) {
    ellipseMode(CORNER);
    ellipse(tipX, tipY-tall/2, wide, tall);
    ellipseMode(CENTER);
}

//draws an ellipse where the first two parameters are the ellipse's right tip
function righttipellipse(tipX, tipY, wide, tall) {
    ellipseMode(CORNER);
    ellipse(tipX-wide, tipY-tall/2, wide, tall);
    ellipseMode(CENTER);
}

function draw() {

    background(230-colorfade*1.5, 230-colorfade*1.5, 120+bluefade);

    //window
    fill(240-colorfade, 240-colorfade, 230+bluefade);
    noStroke();
    rect(100, 0, 350, 450);

    //dark blue rect
    fill(26, 32, 128);
    rect(125, 0, 325, 425);

    //moon
    noStroke();
    fill(250, 250, 240, moonview); //moon white
    ellipse(300, moonY, 80);
    fill(26, 32, 128); //dark blue circle to make it a crescent
    ellipse(290, moonY-10, 70);

    //light blue sky color
    fill(185, 240, 250, windowTransparent);
    rect(125, 0, 325, 425);

    //table
    fill(110-colorfade, 60-colorfade, 37+bluefade); //brown
    rect(0, height-50, width, 50);
    //fill(100, 50, 27); //darker brown

    //plant stem
    stroke(74-colorfade, 150-colorfade, 74+bluefade); //green
    strokeWeight(stemweight);
    strokeCap(ROUND);
    line(potCenterX, potCenterY, potCenterX, plantTipY);
    noStroke();

    // the y coordinate of a point half the distance up the stem
    var yspot1 = potCenterY-(dist(potCenterX, potCenterY, potCenterX, plantTipY)/2);

    // y coordinate of a point 3/4 the distance up the stem
    var yspot2 = potCenterY-(dist(potCenterX, potCenterY, potCenterX, plantTipY)*(3/4));

    // y coordinate of a point at the top of the stem
    var yspot3 = potCenterY-(dist(potCenterX, potCenterY, potCenterX, plantTipY));

    //drawing them leaves at set points up the stem

    fill(90-colorfade*2, 180-colorfade*2, 90+bluefade); //leaf green

    //bottom right
    push();
    translate(potCenterX, yspot1);
    rotate(leftRotate);
    lefttipellipse(0, 0, leafSizeX, leafSizeY);
    pop();

    //bottom left
    push();
    translate(potCenterX, yspot1);
    rotate(rightRotate);
    righttipellipse(0, 0, leafSizeX, leafSizeY);
    pop();

    //middle right
    push();
    translate(potCenterX, yspot2);
    rotate(leftRotate);
    lefttipellipse(0, 0, leafSizeX*(7/8), leafSizeY*(7/8));
    pop();

    //middle left
    push();
    translate(potCenterX, yspot2);
    rotate(rightRotate);
    righttipellipse(0, 0, leafSizeX*(7/8), leafSizeY*(7/8));
    pop();

    //top right
    push();
    translate(potCenterX, yspot3);
    rotate(leftRotate);
    lefttipellipse(0, 0, leafSizeX*(2/3), leafSizeY*(2/3));
    pop();

    //top left
    push();
    translate(potCenterX, yspot3);
    rotate(rightRotate);
    righttipellipse(0, 0, leafSizeX*(2/3), leafSizeY*(2/3));
    pop();

    //pot
    fill(230-colorfade, 140-colorfade, 83+bluefade); //salmon
    rectMode(CENTER);
    rect(potCenterX, potCenterY, 120, 150);
    triangle(potCenterX-60, potCenterY-75, potCenterX-60,
        potCenterY+75, potCenterX-80, potCenterY-75);
    triangle(potCenterX+60, potCenterY-75, potCenterX+60,
        potCenterY+75, potCenterX+80, potCenterY-75);
    fill(240-colorfade, 150-colorfade, 93+bluefade);
    rect(potCenterX, potCenterY-90, 170, 60);
    rectMode(CORNER);

    //as move mouse left to right, the sky gets darker and colors fade to bluer shade
    windowTransparent = map(mouseX, width, 0, 0, 255);
    bluefade = map(mouseX, width, 0, 0, 40, true);
    colorfade = map(mouseX, 0, width, 0, 40, true);

    //as move mouse left to right, moon comes up
    moonY = map(mouseX, 0, width, 375, 100, true);
    moonview = map(mouseX, 0, 450, 0, 255);

    //as move mouse up and down, plant grows
    plantTipY = map (mouseY, height, 0, potCenterY, 230); //gets taller
    stemweight = map (mouseY, height, 0, 5, 25); //stem gets thicker
    leafSizeX = map (mouseY, height, 0, 50, 150); //leaves get longer
    leafSizeY = map (mouseY, height, 0, 30, leafSizeX/3); //leaves get taller
    leftRotate = radians(map(mouseY, height, 0, 270, 340)); //right leaves open up
    rightRotate = radians(map(mouseY, height, 0, 90, 20)); //left leaves open up
    //plant pot

}

LO 3 – Computational Fabrication

The reason why I so admire the Voronoi architecture statue made by June Lee is that I am really impressed by the organic form in architecture. The Voronoi diagram is a type of partition created by segmenting midpoints of distances of different points. To make this random geometric two-dimensional diagram look smooth and organic, the creator smoothened the shape of each Voronoi cell in grasshopper, then using the negative space created by smaller smoothened cells and the square border of the cube, the creator made a wall with organic Voronoi shaped holes. One great thing about using the grasshopper algorithm to generate shapes is that it allows the creator to easily tweak and manipulate every aspect of the geometry. For example, in this project, June Lee is able to change the size of the cube, how big the holes are, and even how smooth those holes are, without remaking the whole shape.

Voronoi Cube by June Lee

source

Project 03: Dynamic Drawing

  1. Size of large circle changes
  2. Shade of large circle changes
  3. Rotation of smaller circle changes
  4. Stroke of smaller circles changes 

var uniX = 0;
var uniY = 0;


function setup() {
    createCanvas(600, 450);
    background(0);
}

function draw() {
    uniX = mouseX;
    uniY = mouseY;
    background(0);
    push();
    fill(255);
    ellipse (uniX,uniY,200);
    pop();
    for (let i = 25; i <= 575; i+=50)
    {
        for (let j = 25; j <= 425; j+=50)
        {
            circleChange(i,j);
        }
    }
}

function circleChange(Cx,Cy) {
    distanceO = Math.sqrt((uniX-Cx)*(uniX-Cx) + (uniY-Cy)*(uniY-Cy));
    distance = constrain(distanceO, 10, 200);
    var diameter = distance/4;
    var angle = Math.atan2((uniY-Cy),(uniX-Cx));
    push();
    strokeWeight(1);
    stroke(0,0,255,255);
    noFill();
    arc(Cx, Cy, diameter, diameter, -0.25*PI, 0.75*PI);
    pop();
    push();
    strokeWeight(1);
    stroke(255,0,0,255);
    arc(Cx, Cy, diameter, diameter, 0.75*PI, 1.75*PI);
    pop();

    push();
    strokeWeight(0);
    fill(distance/200*255);
    ellipse (Cx,Cy,diameter-2);
    pop();

    fill(255);
    strokeWeight(distanceO/60);
    ellipse((Cx+diameter*Math.cos(angle)/3),(Cy+diameter*Math.sin(angle)/3),diameter/3);

}

anabelle’s project 03

This is my project! Try making the sky change from sundown to midnight, see the moon change phases, and the stars glitter! You can try to pet the cat as well <3

sketch
// kayla anabelle lee (kaylalee)
// section c
// project 03 ^^

moonX = 200; 
moonY = 150;
outline = 55;
inline = 50;

let direction = 0.8;
let speed = 1;
let starDiam = 20; 

let redValue = 231;
let greenValue = 157;
let blueValue = 193;

let skyScraperX = 300;
let skyScraperY = 100;

let happyMouthX = 60;
let happyMouthY = 450;

let triangleWindowX = 225;
let triangleWindowY = 185;
let catDirection = 1;
let catAngle = 1;
let moonSpin = 0;

function setup () {
    createCanvas(450, 600);
}

function draw() {
    print(catAngle);
    background(redValue, greenValue, blueValue);

    // constrain the rbg values to the 2 sky colors i want
    redValue = constrain(redValue, 46, 231);
    greenValue = constrain(greenValue, 26, 157);
    blueValue = constrain(blueValue, 71, 193);

    // turns dusk when mouse on left, turns night when mouse on right
    if (mouseX > width/2) { 
        redValue -= 3;
        blueValue -= 3;
        greenValue -= 3;

    } if (mouseX < width/2) {
        redValue += 3;
        blueValue += 3;
        greenValue += 3;
    }

    // moon cycle
    if (mouseX <= 100) {
        newMoon(35, 290, 30, 30);
    } if (100 < mouseX & mouseX <= 200) {
        crescentMoon(115, 110, 30, 30);
    } if (200 < mouseX & mouseX <= 300) {
        gibbousMoon(190, 50, 30, 30);
    } if (300 < mouseX) {
        fullMoon(300, 50, 30, 30);
    }

    // triangular building
    stroke(164, 96, 175);
    strokeWeight(1);
    fill(119, 127, 199);
    fill(230, 209, 242);
    quad(95, 600, 220, 170, 390, 170, 390, 600);

    // triangle building windows
    // im sorry i couldnt use a forLoop for these as well -- whenever i tried, the program wouldnt load

    triangleWindow(triangleWindowX,triangleWindowY);
    triangleWindow(triangleWindowX - 5, triangleWindowY + 20);
    triangleWindow(triangleWindowX - 10, triangleWindowY + 40);
    triangleWindow(triangleWindowX - 15, triangleWindowY + 60);
    triangleWindow(triangleWindowX - 20, triangleWindowY + 80);
    triangleWindow(triangleWindowX - 25, triangleWindowY + 100);
    triangleWindow(triangleWindowX - 30, triangleWindowY + 120);
    triangleWindow(triangleWindowX - 35, triangleWindowY + 140);
    triangleWindow(triangleWindowX - 40, triangleWindowY + 160);
    triangleWindow(triangleWindowX - 45, triangleWindowY + 180);
    triangleWindow(triangleWindowX - 50, triangleWindowY + 200);
    triangleWindow(triangleWindowX - 55, triangleWindowY + 220);
    triangleWindow(triangleWindowX - 60, triangleWindowY + 240);
    triangleWindow(triangleWindowX - 65, triangleWindowY + 260);

    // skyscraper
    fill(217, 196, 236);
    stroke(164, 96, 175);
    strokeWeight(1);

    rect(300, 100, 150, 500);
    rect(350, 45, 100, 55);
    triangle(350, 40, 450, 0, 530, 40);

    // skyscraper windows
    for(skyScraperX = 300; skyScraperX < 440; skyScraperX += 40) {
        for(skyScraperY = 100; skyScraperY < 650; skyScraperY +=40) {
            push(); 
            translate(20, 20);
            skyWindow();
            pop();
        }
    }

    // happymouth building
    stroke(164, 96, 175);
    strokeWeight(1);
    fill(204, 183, 229);
    rect(40, 430, 195, 170);
    rect(50, 380, 170, 40);

    textSize(25);
    fill(244, 244, 211);
    stroke(119, 127, 199);
    text("happyMouth()", 60, 405);

    // happymouth windows
    for(happyMouthX = 40; happyMouthX < 200; happyMouthX += 60) {
        for(happyMouthY = 420; happyMouthY < 600; happyMouthY += 30) {
            push(); 
            translate(15, 30);
            happyWindow();
            pop(); 
        }
    }

    // if mouse on happymouth sign, stars pulse AND crescent moon rotates
    if (dist(135, 390, mouseX, mouseY) < 30) {
        starrySky();
        starDiam += direction * speed;

        if (starDiam > 30) {
            direction = -direction;
            starDiam = 30;

        } if (starDiam < 0) {
            direction = -direction;
            starDiam = 0;  
        } 

    } else starrySky();

    // rooftop building
    fill(177, 156, 216);
    stroke(64, 96, 175);
    quad(185, 550, 270, 420, 430, 420, 410, 550);
    fill(190, 169, 223);
    rect(185, 550, 225, 50);
    quad(410, 600, 410, 550, 430, 420, 430, 600);

    // cat perch and cat
    fill(117, 80, 166);
    rect(0, 180, 150, 60);

    cat(130, 120, 10, 10)
    triangle(43, 69, 39, 78, 45, 78);
    triangle(74, 82, 64, 84, 72, 93);

    push();
    rotate(radians(catAngle*catDirection));
    push();
    scale(0.7);
    rotate(radians(-20));
    catTail(-50, 250, catAngle*catDirection); 
    pop();
    pop();

    // cat tail animation
    if (dist(60, 50, mouseX, mouseY) < 50) { 
        push();
        rotate(radians(catAngle*catDirection));
        push();
        scale(0.7);
        rotate(radians(-20));
        catTail(-50, 250, catAngle*catDirection); 
        pop();
        pop();
    
        catAngle -= 1;
        if (catAngle < -10) {
            catAngle = -10;
        }

        } if (dist(40, 120, mouseX, mouseY) < 50) {
            catAngle += 1;
            if (catAngle > 10){
                catAngle = 10;
            }
   
        }
    }

// my catalogue of functions 

function cat(x, y, w, h) { 
    fill(50);
    noStroke();
    ellipse(x/2, y/2, 50, 50);
    ellipse(x/2 + 17, y/2 + 5, 25, 28);
    ellipse(x/2 - 20, y/2 + 65, 70, 100);
    arc(x/2 - 20, y/2 + 120, 90, 70, radians(180), radians(0));

    triangle(x/2 + 5, y/2 - 15, x/2 + 20, y/2 - 15, x/2 + 13, y/2 - 35);
    triangle(x/2 - 5, y/2 - 15, x/2 - 20, y/2 - 15, x/2 - 13, y/2 - 35);

    bezier(x/2 - 20, y/2 + 5, x/2 - 30, y/2 + 30, x/2 - 30, y/2 + 20, x/2 - 40, y/2 + 25);
    bezier(x/2 + 10, y/2 + 20, x/2 + 5, y/2 + 30, x/2 + 5, y/2 + 40, x/2 + 13, y/2 + 55);
}

function catTail(x, y, catAngle) {
    noStroke();
    beginShape();
    curveVertex(x, y);
    curveVertex(x, y);
    curveVertex(x - 5, y + 40);
    curveVertex(x + 20, y + 100);
    curveVertex(x + 80, y + 140);
    curveVertex(x + 150, y + 150);
    curveVertex(x + 160, y + 140);
    curveVertex(x + 145, y + 120);
    curveVertex(x + 70, y + 100);
    curveVertex(x + 40, y + 50)
    curveVertex(x + 30, y);
    curveVertex(x + 30, y);
    endShape();
}

function triangleWindow(triangleWindowX, triangleWindowY) {
    fill(244, 244, 211);
    quad(triangleWindowX, triangleWindowY, triangleWindowX -5, triangleWindowY + 15, triangleWindowX + 200, triangleWindowY + 15, triangleWindowX + 200, triangleWindowY);
}

function happyWindow() {
    rect(happyMouthX, happyMouthY, 50, 15);
}

function skyWindow() {
    fill(244, 244, 211);
    rect(skyScraperX, skyScraperY, 20, 20);
} 

function newMoon(newX, newY, w, h) {
    outline = 55;
    inline = 50;

    stroke(255);
    fill(redValue, greenValue, blueValue);
    ellipse(newX, newY, outline, outline);
    ellipse(newX, newY, inline, inline);
}
   
function crescentMoon(crescentX, crescentY, w, h) {
    outline = 55;
    inline = 50;

    fill(255);
    ellipse(crescentX, crescentY, inline, inline);
    fill(redValue, greenValue, blueValue);
    noStroke();
    rect(115, 80, outline/2, outline)
    stroke(255);
    noFill();
    ellipse(crescentX, crescentY, outline, outline);
    fill(redValue, greenValue, blueValue);
    noStroke();
    ellipse(crescentX, crescentY, inline/2, inline);
}
   
function gibbousMoon(gibbousX, gibbousY, w, h) {
    outline = 55;
    inline = 50;

    noStroke();
    fill(255);
    ellipse(gibbousX, gibbousY, inline, inline);
    fill(redValue, greenValue, blueValue);
    noStroke();
    fill(redValue, greenValue, blueValue);
    rect(190, 24, outline/2, outline);
    stroke(255);
    noFill();//Outline
    ellipse(gibbousX, gibbousY, outline, outline);
    fill(255)
    arc(gibbousX, gibbousY, inline/2, inline, PI/2, -PI/2);
}

function fullMoon (fullX, fullY, w, h) {
    outline = 55;
    inline = 50;

    noFill();
    stroke(255);
    ellipse(fullX, fullY, outline, outline);
    fill(255);
    ellipse(fullX, fullY, inline, inline);
}

function starrySky() {
    noStroke();
    fill(253, 253, 150);

    circle(140, 30, starDiam/5);
    circle(275, 136, starDiam/7);
    circle(61, 303, starDiam/4);
    circle(167, 38, starDiam/6);
    circle(10, 34, starDiam/7);
    circle(163, 147, starDiam/3);
    circle(292, 121, starDiam/8);
    circle(154, 328, starDiam/5);
    circle(360, 15, starDiam/2);
    circle(19, 386, starDiam/6);
}


// ALL moon functions were made by brantschen at https://editor.p5js.org/brantschen/sketches/bGH-klhrY
// cat mechanics inspired by jiatong li

Looking Outward Blog #3 TREDDY 

TREDDY by F.A.T Lab

The project I admired most is the TREDDY, which is a free software to customize rubber stamps with any artistic ideas. The part TREDDY inspired me the most was its usefulness in daily life. Although other Parametric 3D Project might be artistically pleasant, but most of them have little to do with real life. Maybe in term of stimulations other Projects are useful too, but TREDDY is the most user friendly one that’s open to the public. We can use TREDDY to improve our quality of life by making our rubber stamps visually pleasant to us, and it’s also a great way to create toys for kids.

TEDDY allows us to 3D print through CAD files. In terms of the algorithms, I think that it puts a set of variables into the parametric equations to create shapes on the rubber stamps and the rubber stamps itself. The final form of creator’s artistic sensibilities was demonstrated through the drawing created by of rubber stamps when stained with ink and the rubber stamps itself.

The link to software (found on the blog, but it not working)

TREDDY by Free Art and Technology (F.A.T.) Lab, 2013-: https://fffff.at/wheels

Video: https://vimeo.com/golanlevin/treddy

Caption- The video explaining what TREDDY achieves by Golan Levin.

Windows style dynamic drawing

I am trying to create a grid of circles and using my mouse cursor as an attraction point to control the size and color of the circles. The wavey movement of circles is created by changing the circle rotation angle based on the distance between the mouse cursor and the center of the circles.

//Jason Jiang
//Section E

//Setting variables 
var d = 40;
var size = d/2;
var h = 0;
var s = 0;
var a = 0;
function setup() {
    createCanvas(640, 450);
    angleMode(DEGREES);
    colorMode(HSB);
    
}

function draw() {
    background(0);
    fill(255);
    noStroke();
    //Create Grid of circles using loop
    for (var x = d/2 - d; x < width + d; x = x+d){
        for (var y = d/2 - d; y < height + d; y = y+d){
        var dis = dist(x, y, mouseX, mouseY);
        
        //Change Circle size according to distance
        
        //Remap distance to circle center to angle
        size = map(dis, 0, (width^2+height^2)^0.5, 30, 1);

        //Change Circle color according to distance
        
        //Remap distance to circle center to color value
        h = map(dis, 0, (width^2+height^2)^0.5, 0, 255);
        s = map(dis, 0, (width^2+height^2)^0.5, 50, 100);
        fill(h, s, 100);
        

        //Change circle rotation according to distance

        //Remap distance to circle center to angle
        let a = map(dis, 0, (width^2+height^2)^0.5, 0, 360);
            push();
            translate(x, y);
            rotate(a);
            circle(10, 10, size);
            pop();
        }
    }    
}

Metal and Robot arm

Author: Students in seminar led by Jeremy Ficca

Project Name: Fabricating Customization Seminar

Robot arm deforming the metal. The image is from the project website

The project I admire comes from our school. It is a studio project led by Professor Ficca that experiments with the relationship between how robotic arms interact with metals to create customizable shapes generated by computers. It has the potential to renovate the means of mass-producing metal plates. The precision and rigidity of robot arms make it possible to create them. The process involves using computational design to generate different shapes of metal. Many variables control the final form, such as the panel shape, the number of folds, and the joining location. Such a degree of freedom allows for a range of unique metal forms. The students selectively choose complex shapes to produce manually and experiment with means of producing the shape. Thus, they have to understand how metals are bent to write the correct code to control the robot arms. I adore the project because it not only focuses on generating shapes but also on how to make sure those shapes can be produced physically.