An interactive machine meant to display the properties of oscillation. In it's ideal form, the changes in oscillation will be controlled by the user, who will lay at the base of the object looking up through the tendrils.
Arduino Code: http://pastebin.com/ebuEn4HR
I would like to make a 3D surface capable of displaying various types of data. It will consist of an array of rods and a skin connecting them all at the front. Each rod will be treated as a data point and controlled by Processing and/or Arduino depending on the application. Ideally, I'd like to achieve a high resolution, meaning at least 20 x 20 rods. So far, my only idea for mechanical components is a motorized slide potentiomenter. However, at $20 per slider, it's too expensive. I'll be looking into other options.
If this design is not feasible, I will look into a vertical design (shown below).
In my last post I described how the works of Manfred Mohr, the minimalists and the idea of the cube as a representative of an infinite grid would be my starting points for the final. Those remained true, for the most part, but I put my focus on creating patterns with simple rules based on a grid of cubes.
The final product is a drawing tool of sorts. It creates a 3-dimensional grid of cubes of any number. Those cubes can be rendered with any number of edges. If not 12 sides (a full cube), the edges to be rendered are chosen at random.
The resulting cubes can be seen at different angles using PeasyCam. When an interesting combination is found, it is saved as a vector PDF. The width of the edges and the length of the edges can be manipulated by a set of slider controls in a separate window.
Below are the final five images chosen to be printed. The code can be found here: https://github.com/matthewepler/printing_code/tree/master/epler_final_cubed
I'm interested in pursuing the fundamental concepts of Minimalism and its use of the infinte grid. More specifically, I'd like to make a series of works that use basic lines to give form to a 3D grid of cubes, and then disrupt the grid with random marks.
Here are some references. The first is by Sol Lewitt and demonstrates how the grid can be represented in concrete form while implying infinite dimension in any direction. I will also be using Manfred Mohr's work with cubes and simple grids as a reference (see ReCode Project: http://recodeproject.com)
This work by Nasreen Mohamedi (1970) shows a 2D grid that is disrupted by geometric variation of lines.
Finally, this image by Julie Mehretu shows a playful disruption of grid-like forms with more free-flowing shapes.
Our assignment in Kyle McDonald's Glitch class this week was to create a series of "flip-flops." This refers to the process of taking a digital output and using it for analog input, and vice versa and on and on. In other words, make something with your hands. Then put it in a computer. Let the computer do something to it. Output the result back into analog form (paper print, etc.).
For my project, I wanted to have a drawing back-and-forth with my scanner. I would draw a single drawing, and then give it to the computer and glitch it, then print and start over. What happened was altogether unexpected and forced me to come up with a completely different approach.
When I scanned the original drawing ( see pic below ), the scanner software (Image Capture on Mac OS) was set to auto-detect what it thought might be separate photos on the scanner bed. In my single drawing of a squiggly line, it found 9 separate images. I let it scan those fragments, and printed all 9 of them and drew on top of those. Then I put those 9 drawings back in the scanner to see what it would find.
Ironically, it found nothing but whole pictures in the second round. Confused, I put the original drawing back in and it found the same 9 as it had the first time. When I put a second-round drawing back in the scanner without changing any settings, the scanner kept the exact same 9 frames from the original and scanned those exact areas on the new and subsequent drawings.
The original drawing acted as a calibration image, causing the scanner to remember 9 areas of the scanner bed and scan only those areas for each drawing. The first drawing set the rules for all the other drawings' output.
The entire set can be seen on Flickr: http://www.flickr.com/photos/mattepler/sets/72157631788273573/
A simple sketch made to add glitches to every frame of a .mov file. Each frame is loaded as bytes in Processing and certain bytes are manipulated. This could be built out to include variables for how many frames/sec are manipulated, multiples kinds of manipulation, etc.
One application might be the ability to generate a unique video for each user based off of original one. For example, a music video made available on the band's website can be run through this sketch on the server and then displayed to the user in the browser, or sent to YouTube, etc.
Code lives HERE.
Marilyn is dead. Long live Marilyn!
This week we all shared the same image file and each built a custom function to glitch it. We're going to put all of them together into a master sketch that can visualize all the functions together (and perhaps toggle them, we'll see when we're done). The master file lives on the class repo: https://github.com/ITPNYU/Glitch/tree/master/CorpseAll
Here's a grab of my effect. Every time you run the sketch, it picks a random row and repeats that row of pixels for the remaining rows in the image. Not fancy, but fun when it turns out well. I'm hoping that it will be a good contrast amongst what I expect to be a crazy collection of more "traditionally" glitch-ed versions of the same pick.
*Update - After I wrote this function out by hand, I'm told there's an example that comes with Processing that does the same thing. Oh well, nothing like learning the hard way. To make up for it, I've done a very very simple glitch sketch that lives HERE, and uses a hex-editing approach by manipulating individual bytes in the image file.
Code for my design lives here in my Printing Code repo on GitHub, in the" week_5" folder.
I've also experimented with an idea about how to document visual and textual references for new works. Much of our work as creative coders is inspired by the work of others. If we use someone's code, we usually give attribution in our code by mentioning their name. But what about art works, texts, and other works that inspire us? To solve the problem, I added a "ref" folder to my project folder and included it in the git repo for the project. In side is an image and a text file that notes the source of the image. I look forward to exploring ways to keep track of references and would like to see my thesis include some discussion of this issue.
We were given this code and told to break it...in one hour.
I added more bricks and balls, then got rid of the background, and put the whole thing in 3D space with a lot of rotation calls. The result is a very obtuse drawing tool that is modified by mouse location. Here are some screenshots and my broken code.
Here's a sneak peak at a platform that allows you to generate custom typography. There are a lot of features that need adding, but this will give you an idea of how it works.
The really messy code is here.