SPECIAL TOPICS IN
Information Visualization and Computational Design

Akhil Gupta

Amir Arbabshirani

The process behind this generative form is: I used processing to generate this and there different random events mixed together. There are four main functions which are: flashing lamp (malfunctional lamp), moving ghost, sparking lamp, and background reaction diffusion shapes. The lamp is being turned off and on randomly and repeatedly. When the is turned off the ghost appears and it moves around the window. If the ghost hits the any of the four window sides, it changes it's direction to be visible in the window. When the lamp is turned on everywhere is bright, and the ghost disappears. Also when the lamp is turned on randomly and at random locations some reaction diffusion shapes appear and start to grow.

April

For Mini Project 2, I decided to use the "Color-by-Numbers" concept from the 2013 SIGGRAPH paper, found at: http://graphics.stanford.edu/~mdfisher/papers/patternColoring.pdf. I created a Processing app that colors grayscale patterns using a genetic algorithm. Each generation has twelve versions of a pattern where the first generation is colored randomly. For each generation, a user can select their three favorite colorings and have those be used with other options in the generation to produce a new generation of color options.

The GIF file that I created first shows some examples of how several different designs evolved over generations. The remaining images display a full run of the program. For each generation, the three colorings that were selected are shown and the final image of the GIF is the image that was ultimately selected from that run of the program. The images used for the app can be found in the supplemental materials at the following link: http://graphics.stanford.edu/~mdfisher/patternColoring.html.

Brandon Lites

My generative form relies heavily on randomness. In a 400x400 pixel area, a rectangle is generated at a random x and y point. This rectangle has a random calculated size, with the width and height constrained between 0 and 35 pixels. It is given a random color, and random opacity (RGB/alpha values between 0 and 255) and is drawn. It's coordinates are stored in an array and the next rectangle is drawn with a new set of random parameters. Finally, a line is drawn between the two rectangles from their stored coordinates. This allows a line to be drawn from each consecutively generated rectangle. Lastly, the frame rate increases for number of rectangles drawn. It starts out at 1 frame per 10 seconds is incremented by 1/10 fps each time.

Process

1. Begin with a 400x400 square.
2. Randomly generate a rectangle with width and height between 0 and 35 pixels.
3. Store its coordinates in an array.
4. Randomly assign the rectangle a “fill” color and border color.
5. Randomly assign the rectangle an opacity for both it's fill and border.
6. Repeat the process and draw a line between the newly created rectangle and the previously created rectangle.
7. Assign that line a color and opacity randomly.
8. Increase frame rate by 1/10th.
9. Repeat.

Cameron

For the project relating to Form, I chose to explore human form. The majority of Processing, OpenFrameworks, and Cinder art explores abstract geometric shapes. I wanted to try something different by exploring human form. One of my favorite artists is Christopher Bucklow. I really like his "Guests" series of photographs. In the 1990's, he punctured thousands of holes into aluminum foil in the shadow of models' reflections. He then shined light through the holes onto photographic paper. The resulting images are truly incredible. They remind me of the Daft Punk song "Human After All." After all the technology, we are just humans.

Since I know a little bit about computer programming now, I wanted to see if I could employ a similar process but with code. I found human forms in green screen silhouettes. Then I separated the green pixels from the non-green pixels and stored these "bits" in an array. Then I used the array to populate particles in random locations throughout the human form. Then I layered ellipses behind the particles. Then I iterated the color of the ellipses through the HSB color model.

Cheston

Colby

Rules

1. Start with a white canvas, 0,0 is upper left, width,height are lower right
2. When creating a line, stop either at the edge of canvas or when another line is encountered
3. Start a line with slope m=1 at 0,0, and extend for random distance [1,WIDTH/10]+1 or when rule 2 is satisfied
4. "Turn right" by extending a line with slope m=0 a random distance [1,WIDTH/10] or when rule 2 is satisfied
5. "Turn left" by extending a line with slope m=1 a random distance [1,WIDTH/10] or when rule 2 is satisfied
6. When rule 2 is satisfied, fall back two turns and...
7. "Turn left" by extending a line "up" with slope m=-1 a random distance [1,WIDTH/10] or when rule 2 is satisfied
8. "Turn right" by extending a line straight down, a random distance [1,WIDTH/10] or when rule 2 is satisfied

Daniel Gomez

The images of JT Nimoy for the Disney film Tron: Legacy are the inspiration of my final product. These radial designs conveyed the sleek and futuristic look that I desired for my creation.

The second version of the project involved drawing many small arcs of varying length. The arcs were filled with a variation of a color chosen at random. I felt that this version was closer to what I had originally envisioned. Although it was an improvement, aside from the color, the circles were still difficult to distinguish between one another. I aimed to keep this sleeker design, but needed to simplify the circles further.

The final version of the project is shown below. I increased the size of the arcs to create a simpler circle. With these larger arcs, the difference between each generated circle became more apparent, even if they had similar color.

David Collins

Step 1: Pick three random points in the parametric plot

Step 2: With fill set to a transparent red, draw a Bezier curve with the anchors at (0,0) and the third random point and handles at first and second points.

Step 3: Add another Bezier curve, do the same as step 2, except switch the two points of the handles

Step 4: Repeat 30 times (90 random points, take a set of 3 points each time and make two Bezier curves).

Step 5: Do step 4, reflecting across the following three lines: y=0, y=x, y=-x

To animate, add .01 to each point. For removal of jagged edges, enable anti-aliasing.

Eros Espinola

The Star: Description

In this project I wanted to create something related with the space, I feel that outer space images and visualizations are pretty harmonical. With The Star visualization I tried to express the aspects I perceive from outer space scenarios: peace, silence, and beautiful combination of colors.

One of my favorites celestial bodies are the stars, beautiful and simple. I tried to show a big 3D star in the middle of an outer space scenario, where the star produces solar flares, the reason of its movement. I created all this with basic figures such as lines and spheres. The star has different layers of spheres and every layer has lines in their surface that connect with the layers of other spheres, the spheres change their radius in every frame, so the lines are moving in different positions. I chose black as a background color and white for the small stars moving in the back. The main star is a yellow/orange color, which I think combines pretty good with the other colors.

Evee

The Galaxy Charm Bot retweets messages from recent searches with the hashtag "#charming." Using the tag begins to show the scope of what Twitter users find "#charming." Unbeknownst at the time of creation, "Charming" is the name of a character from a primetime television show. As a result, there is some frequency of retweets related to "Once Upon a Time."

James

Jess

John-Mark

The scripts access your webcam and adjust the location and color of the generation based on the surrounding movement. The interaction is extremely subtle, but if there were no motion at all, the images would be completely grayscale.

Julian

The following generative art piece was created to show the flow pattern of an invisible force. From inspection it can be seen that the arrows seem to flow in a smooth non-random pattern. The idea for the piece was to see the flow pattern from various forces, much like that found in differential equations. Bouncing balls and the force created from them hitting each other creates this flow pattern that the arrows follow.

Luke

Marco

Rectangle warfare:

The following animation randomly generates a series of rectangles on a gray/blue scale, which can move in two possible directions (vertical/horizontal). Every time that one of the rectangles collide with another, both start to shrink. Finally a pattern of circles its created oscillating towards the biggest rectangle.

Mason

My final design incorporated all of these elements. I wrote a function that would increase and decrease the radius of my matrix of spheres. I also filled in the matrix with different colors depending on location, and I made the whole matrix rotate around the x, y, and z axis at different speeds. My final product was a matrix of bright colored spheres that grew larger and smaller and rotated around the origin.

Mauricio David

This visualization aims to show a simple, yet interesting-looking shape, using no more than just lines, something that could loop over and you could just keep looking at for some time, you can move around using the mouse to see it on different angles.

I started out with a line, then turn it into a spiral, the radius is set according to a custom polynomial function I modeled to give it an interesting look, I connected the start and ending points by setting each vertex' position to a sine function so that it would go up, then down, then back up, some displacement is applied to the radius function to give it a wavy-look on its walls.

I clone these lines, rotate them evenly across a circumference, and vary the rotation and displacement given a time value, giving its final result.

All of these transformations were applied via WebGL shaders.

Meghana

The night sky:

I have done this animation using processing. I have created the night sky because I love looking at it and it gives me a solace looking at the stars and the moon. While I was in the beginning stages of learning the tool, I was looking through the examples, I felt I should create a simple animation that brings out the most. I started working on the idea which turned out to be not that great. I wasn't satisfied.

One night I was just staring into the sky at night, I suddenly felt the urge to try it out on the tool. I decided to give it a shot. So, I experimented with the dots alone using the random function. The dots created the shining stars and then I worked on the moon. I collaborated both of them to get the effective animation of the night sky.

Patrick

Stephen Ransom

My project was an experiment with using a series of user defined constraints and random numbers to produce an animation. It lays down N ellipses for a background, then begins drawing lines on top of them and changing the color of each drawn ellipse based on user defined speeds. The program relies heavily on random numbers but allows the user to define the following:

Line Draw speed
Line min thickness and max thickness
line color ranges
number of ellipses
size of ellipses
color range of ellipses
transparency of ellipses
color update speed of ellipses

Each of these can be easily defined in the setup function, and greatly alter the final animation.

Steven Garcia

For Mini-Project 2 I implemented the paper "Generalization of Conways' "Game of Life" to a continuous domain - SmoothLife" by Stephan Rafler. In his paper Rafler presents a generic generalization of Conway's "Game of Life" to a continuous domain. Both the simulation and visualization were implemented entirely on the GPU in OpenGL.

Tanya

For this second mini project I wanted to be able to generate images looking like something Mondrian would have made. Initially I was thinking of his paintings with the bold black lines against white background with the occasional rectangle filled in with a primary color.

Visually I wasn’t caring for what I was coming up with so far, and even imagining what it would look like after adding larger colored blocks to the top didn’t appeal to me. The first thing I started to do was add more color in the form of thin yellow horizontal or vertical rectangles to the image. Removing the grid lines after that seemed to clear it up more as well.

Happier with these results I decided to change my goal to producing something more like Mondrian’s Broadway

Subsequently I changed the colors to match those within the Mondrian original. After that it was basically a lot of tinkering with my code to make sure that I didn’t have yellow rectangles running next to each other, that I had a decent amount of small red, blue or gray squares, and that I had larger color blocks layered on top in a random fashion. Rather than using the same brick red in the original for the larger blocks I decided to go with a brighter red. The generated images popped out more to me that way.

Veera

Vagueness of life:

I was always thought that the life had no particular pattern. It never followed any rules or design to reach the destination. Once a person is born, the life starts unraveling itself and moulds at unexpected twists and turns. This is all a package. This thought led me to design my animation.

The white part represents the things in life that we love to do and want to do. The black lines are the responsibilities that we can't neglect and we should fulfill at any cost. As the life unfolds itself slowly, which is as we grow older, the darklines occupy most of the space. one day when we look back there would be no white space at all. All this seems simple when looked at, from a perspective. But, when one starts experiencing, only then does one know about the gravity of all the responsibilities. Beauty lies in balancing both the white and black spaces. But many people cannot handle this and end up becoming a machine whose sole purpose is to fulfill the responsibilities. Through my animation, I have tried to show the same thing. The plane starts all white and slowly is filled up with the black lines and eventually the arena is completely occupied by the darkness.

Vivek Ramadoss

The idea behind this form was to create an interesting aesthetic based on the frequency data of a given audio file. The way I went about accomplishing this was to have a user-defined grid of particles. Each particle orbits within its cell. The color and orbit rate of the particle is based in the frequency it is assigned. Then based on the frequencies in the audio file the corresponding particle's alpha value fluctuates in real-time.

The song I used for the included GIF animation was Madcon's Beggin'.