Laser Cutting Computationally Generated Forms
For this assignment in my Computational Fabrication course, I created a few designs using Processing, a simple IDE and library for learning to code that is quite useful for quickly drawing up some computational designs using the built-in functions. For 2 of my designs, I simply started with some simple shapes and parameters to edit them before passing them through loops to generate geometric forms with interesting variation. The third design I manually put together with inspiration from album art by one of my favorite artists. I then worked in Rhino to prepare 2 of the designs for engraving and cutting in a laser cutter. Special thanks to Quinn Pearson from the BTU Lab at CU Boulder for setting me up and walking me through the process of working with the laser cutters in the BTU Lab.
MaterialsPermalink
For materials, I ended up using some 0.2 inch thick pine wood sheets that I found at Michaels. This was a good thickness for the laser cutter and allowed some deeper engravings in the designs. The sheets’ dimensions were 5.2 x 12 inches. For the assignment, the 2 selected designs needed to be cut or engraved in at least 5 x 5 inches of material.
Computational Designs and ResultsPermalink
Cross-Section SpherePermalink
To preface my choice of designs, I will say that I enjoy the aesthetics of wireframes. This preference of mine is likely due to being able to see through the objects and thus see more of their overall form. While this first design is not necessarily a wireframe, I constructed it while only drawing the edges, so it had the same aesthetics. In the end, I decided to remove the edges and fill the ellipses in the design with a red gradient.
For this design and the next, I was focusing on constructing 3D-looking objects with only 2D shapes from the Processing library. I attempted to create a tilted sphere with a series of ellipses, producing a cross-section effect. Using polar coordinates, I looped from 180 degrees, representing the left side of the unit circle, to 0 degrees, representing the right side of the unit circle. Along the way, the Cartesian x and y coordinates are retrieved to used for the position and height of the ellipses, respectively. The resulting output can be seen below.
Processing OutputPermalink
CodePermalink
| void setup() | |
| { | |
| size(1000, 1000); | |
| noLoop(); | |
| noStroke(); | |
| } | |
| // Functions to convert polar coordinates to cartesian | |
| float getPolarX(float radius, float theta) { | |
| return radius * cos(radians(theta)); | |
| } | |
| float getPolarY(float radius, float theta) { | |
| return radius * sin(radians(theta)); | |
| } | |
| // Main draw function, runs only once because of noLoop() | |
| void draw() { | |
| int cx = width / 2; | |
| int cy = height / 2; | |
| // Looping through angles (approximately between 180 and 0) | |
| for (float a = 170; a > 5; a -= 7) { | |
| fill(255 - a, 0, 0); // Color shades of red based on angle | |
| float x = cx + getPolarX(300, a); // x coordinate of ellipse is converted from polar | |
| ellipse(x, cy, 40, getPolarY(300, a)*2); // ellipse height varies with y coordinate | |
| } | |
| } |
Fish-Eye Wireframe CubesPermalink
This design was the result of much trial and error. I did a lot of experimenting, tweaking parameters and shifting squares and lines around until I settled on rendering angled cubes in a grid. To give an appearance of the grid bursting out towards the screen, I angled the cubes farther away from the center proportional to their position relative to the center. This sort of created a fish-eye lens effect, with objects on the edge of the screen stretching out more.
Processing OutputPermalink
Laser-Engraving ResultPermalink
CodePermalink
| void setup() { | |
| size(1000, 1000); | |
| noLoop(); | |
| noFill(); | |
| } | |
| // Function to draw a cube | |
| void drawCube(float x, float y, int size, float thetaX, float thetaY){ | |
| // x: x-position of top left corner of square | |
| // y: y-position of top left corner of square | |
| // size: length of square edge | |
| // thetaX: deflection angle (pixels) from negative z-axis along x-axis | |
| // thetaY: deflection angle (pixels) from negative z-axis along y-axis | |
| // Lines will always start from x, y, x+size, and y+size | |
| // End of lines will vary based on angles | |
| square(x, y, size); | |
| line(x, y, x+thetaX, y+thetaY); | |
| line(x+size, y, x+size+thetaX, y+thetaY); | |
| line(x, y+size, x+thetaX, y+size+thetaY); | |
| line(x+size, y+size, x+size+thetaX, y+size+thetaY); | |
| square(x+thetaX, y+thetaY, size); | |
| } | |
| void draw() | |
| { | |
| // Cube sizes | |
| int[] sizeArray = {8, 12, 16, 20, 24, 20, 16, 12, 8}; | |
| // Attempting to achieve a spherical form with the grid of cubes, instead ending up with fish-eye | |
| float[] sphereArray = {100, 50, 25, 12.5, 0, -12.5, -25, -50, -100}; | |
| // Floats for angling cubes horizontally and vertically | |
| float thetaX = -40.0; | |
| float thetaY = -40.0; | |
| // Integers for looping through arrays | |
| int xi = 0; | |
| int yi = 0; | |
| // Loop through grid of positions and draw cubes | |
| for(int x = 75; x < 950; x+=100) | |
| { | |
| for(int y = 75; y < 950; y+=100) | |
| { | |
| int xValue = sizeArray[xi]; | |
| int yValue = sizeArray[yi]; | |
| // Pick smallest size from x and y position using ternary conditional operation | |
| int finalSize = xValue < yValue ? xValue : yValue; | |
| // Adjust x and y to account for excess movement | |
| float adjustedX, adjustedY; | |
| int margin = 30 - finalSize; | |
| adjustedX = x + (margin / 2); | |
| adjustedY = y + (margin / 2); | |
| // Draw cube with adjusted x and y coordinates modified by fish-eye array | |
| drawCube(adjustedX + sphereArray[xi], adjustedY + sphereArray[yi], finalSize, thetaX, thetaY); | |
| // Increment to next position and increment angles | |
| thetaY += 10.0; | |
| yi++; | |
| } | |
| thetaX += 10.0; | |
| thetaY = -40.0; | |
| xi++; | |
| yi = 0; | |
| } | |
| } |
Crescent MoonPermalink
The framing of this design is based on the artwork by Alex Pryle for the album cover of Sweet Nothings by Plini. Since I liked this piece so much, I initially attempted to recreate each element with mathematical functions and basic shapes, but I was quickly overwhelmed with the minute details of the rocket ship. I kept the crescent moon and black hole in the center and added sinewy connections to the border of the design to produce a dissonance between the astrophysical centerpiece and biological backdrop. The connections are created using spline curves, and then I programmed some arcs with a white stroke to overwrite the connecting portions of the curves of the crescent and the center circle. This ensured that the laser cutter would not cut off sections that were needed.
InspirationPermalink
Processing OutputPermalink
Laser-Cutting ResultPermalink
CodePermalink
| void setup() | |
| { | |
| size(1000, 1000); | |
| background(255); | |
| noLoop(); | |
| } | |
| // Renders a crescent moon in the center of the window | |
| void moonBackground(int cx, int cy) { | |
| pushMatrix(); | |
| // Transformations for circles making up crescent and occluding arc | |
| translate(cx, cy); | |
| rotate(radians(-25)); | |
| scale(1.2); | |
| // Two circles, inner circle occluding outer to form outer crescent | |
| stroke(0); | |
| fill(255); | |
| circle(0, 0, 500); // Outer circle | |
| circle(70, 0, 450); // Inner circle (offset by x+70, radius-50) | |
| // Arc to occlude inner circle along its intersection with outer circle | |
| noStroke(); | |
| fill(255); | |
| arc(118, 0, 450, 450, radians(270), radians(450), CHORD); | |
| popMatrix(); | |
| } | |
| // Draws borders that support the center | |
| void border() { | |
| stroke(0); | |
| noFill(); | |
| // Loop through inner and outer border, drawing concentric rectangles | |
| int borderSize = 1; | |
| for (int i = 0; i < 2; i++) { | |
| line(borderSize, borderSize, width - borderSize, borderSize); | |
| line(borderSize, borderSize, borderSize, height - borderSize); | |
| line(borderSize, height - borderSize, width - borderSize, height - borderSize); | |
| line(width - borderSize, borderSize, width - borderSize, height - borderSize); | |
| borderSize = 100; | |
| } | |
| // Could have also just used rect(), but lines make it easier to specify displacement from window edges | |
| } | |
| // Connect borders to crescent centerpiece using curves | |
| void borderConnections() { | |
| stroke(0); | |
| // Top border connection | |
| curve(40, 40, 350, 100, 350, 250, 60, 120); | |
| curve(width-40, 40, 450, 100, 550, 250, width-60, 120); | |
| // Left border connection | |
| curve(40, 40, 100, 400, 250, 400, 60, 120); | |
| curve(40, height - 40, 100, 575, 220, 520, 60, height - 120); | |
| // Bottom border connection | |
| curve(40, height - 40, 400, height - 100, 400, height - 250, 60, height - 120); | |
| curve(width - 40, height - 40, 600, height - 100, 550, height-250, width - 60, height - 120); | |
| // Overwriting border lines with white to allow connection | |
| stroke(255); | |
| line(351, 100, 449, 100); // Top | |
| line(100, 402, 100, 573); // Left | |
| line(401, height - 100, 599, height - 100); // Bottom | |
| // Additional lines for central circle connections | |
| line(551, 100, 749, 100); | |
| line(width - 100, 201, width - 100, 399); | |
| line(width - 100, 551, width - 100, 749); | |
| // | |
| } | |
| // Drawing over crescent sections with white to connect to border | |
| void arcOverwrites(int cx, int cy) { | |
| pushMatrix(); | |
| // Transformations to match crescent moon background | |
| translate(cx, cy); | |
| scale(1.2); | |
| // Arcs matching curved border connections | |
| stroke(255); | |
| noFill(); | |
| strokeWeight(4); | |
| arc(0,0, 500, 500, radians(247.3), radians(261.1)); // Top | |
| arc(0,0, 500, 500, radians(181.5), radians(191.2)); // Left | |
| arc(0,0, 500, 500, radians(85.7), radians(100.4)); // Bottom | |
| popMatrix(); | |
| // Spline curve connections to central circle | |
| stroke(0); | |
| strokeWeight(1); | |
| // Top connection | |
| curve(40, 40, 550, 100, 450, 475, 60, 120); | |
| curve(width-40, 40, 750, 100, 510, 550, width-60, 120); | |
| // Right-top connection | |
| curve(width-40, 40, width-100, 200, 500, 488, width-60, 120); | |
| curve(width-40, height - 40, width-100, 400, 550, 530, width-60, height-120); | |
| // Right-bottom connection | |
| curve(width-100, 40, width-100, 550, 550, 500, width-120, 120); | |
| curve(width-40, height - 40, width-100, 750, 500, 550, width-60, height-120); | |
| // Central circle | |
| fill(255); | |
| circle(cx, cy, 120); | |
| pushMatrix(); | |
| translate(cx, cy); | |
| // Concealing arcs for central circle connections | |
| stroke(255); | |
| strokeWeight(4); | |
| arc(0,0, 120, 120, radians(272), radians(309)); // Top | |
| arc(0,0, 120, 120, radians(323), radians(357)); // Left | |
| arc(0,0, 120, 120, radians(20), radians(62)); // Bottom | |
| popMatrix(); | |
| } | |
| // WIP, currently only uses crescent function to draw a raster crescent for etching | |
| void etching(int cx, int cy) { | |
| pushMatrix(); | |
| // Transormations to put crescent inside central circle | |
| translate(cx, cy); | |
| scale(0.8); | |
| strokeWeight(1); | |
| crescent(); | |
| popMatrix(); | |
| } | |
| // Basic raster crescent drawing function | |
| void crescent() { | |
| // Outer crescent circle | |
| stroke(0); | |
| fill(0); | |
| circle(0, 0, 100); | |
| // Inner crescent circle | |
| fill(255); | |
| circle(15, -10, 90); | |
| // Occluding arc | |
| stroke(255); | |
| fill(255); | |
| strokeWeight(6); | |
| arc(17, -10, 90, 90, radians(245), radians(410), CHORD); | |
| } | |
| // Main draw function, executes only once due to noLoop(); | |
| void draw() { | |
| // Coordinates for center of window | |
| int cx = width / 2; | |
| int cy = height / 2; | |
| border(); | |
| borderConnections(); | |
| moonBackground(cx, cy); | |
| arcOverwrites(cx, cy); | |
| etching(cx, cy); | |
| } |
Conclusion (and Problems Faced)Permalink
I learned a ton about laser cutting by using these simple designs. With proper standards and procedures set in place, it is actually quite simple to get a cut done. However, other issues can present themselves. For example, after importing my SVG files to Rhino, I realized they were broken beyond repair. The reason was that any fill color used in Processing was primed for raster engraving. This means that when there is an area that needs to be operated on, the laser cutter will go pixel by pixel in that area to ablate material as opposed to using a vector method to move between points. I did not realize any color, including white, would be treated this way while working, so extensive work needed to be done to edit the outputs to appear the same in Rhino as they did in Processing. My tip would be to try to make designs with noFill() enabled so that only lines are drawn, and only enable fill(0) when a particular engraving needs to be done. If you don’t do this, then your SVGs and PDFs will have a plethora of invisible shapes that will show up in Rhino and break your design.