Author Archives: Shreeda Segan

System: Molnar Lines

For my conference project, I am further exploring the works of Vera Molnar. She was a pioneer in computer based artwork, having first started by using a plotter. A lot of her works represent or came out of gradualism – modifying the form of something known in very slow ways until it turns into something very unknown, and interesting. I was hooked by her works in which Vera helps a viewer imagine what a plausibly different shape could be. I also appreciated how Vera abstracts away from known legible features in our world (such as handwriting) and studies it with rigor in order to extract the most visually fundamental qualities to handwriting. This is well represented in her 1987 work, Lettres de Ma Mere:

Lettres de ma Merre (1987)

Lettres de ma Merre (1987)

The piece of hers that has been my greatest inspiration in my conference work is Interruptions (1968):

Interruptions (1968)

Interruptions (1968)

It was easy to get a straight forward replication of Molnar’s work, disregarding the empty patches in her composition. It looked something like:

an early verison of Interruptions, with some color.

an early version of Interruptions, with some color. an even earlier draft was monochrome: a simple off-white/grey background and black lines

The lines in the given picture are actually all rotating. After meeting for conference in which we talked about an earlier version of my conference work, I learned that Vera Molnar’s style of work involves thinking of a simple rule and formalizing it. The class made some simple suggestions that should theoretically have some powerful effects for the system. Thus came my first ‘formalized’ rule: adding random length to lines if they were shorter than a certain length:

adding length to certain lines The next few rules I added modified the rotation of the lines and also the color of the lines. It took me a while to figure out how to randomly assign color to each of the lines independently. While doing this, I certainly learned about the weird quirks of Processing as a library. Even though it intuitively makes sense to color a shape when you create it, you actually have to tell Processing what color to use for this shape every frame. Processing is kind of like an artist who only holds one pen, but draws very very quickly, so it needs to swap pens to draw each line, each time it draws that line. So to fix this, you instead tell the shape to remember what color it should be, and have it set the stroke() color (tell Processing what color pen to pick up) on each iteration of .display(). For the first several implementations of my sketch with the introduction of the new rules, I had coded something so that the color for all the lines was randomly assigned. It took me a while to figure out that I had to tell Processing to change colors in the .display() function of the Line object. Finally I had something that looked like this:

randomly colored individual lines

randomly colored individual lines

After learning this, I think color really went right in my system. I was able to then modify the color with more control. This also addressed one of the criticisms about my rules when she saw my work in open-studio: my rules were looking too random. The point of gradualism is for the viewers to get some intuitive sense that a systematic rule is at place. I was finally starting to get systems that look more like:

more controlled color

more controlled color

The way color is implemented is very special – it isn’t actually hard-coded into the system. Actually, the system decides for itself what colors to use for its lines (actually each line decides for itself, creating a complex system out of simple individual decisions) , and this part of the program is recursive. A line modifies its color based on the colors in the lines surrounding it. (Specifically, based on the color of the line previous to it in the array.)

Before I talk about what went ‘easy’ or ‘right’ and what went ‘difficultly’ or ‘wrong,’ I want to comment on how there isn’t always a relationship between how easy or hard something is to conceive of, imagine, and see in your head, and how easy or hard it is to code.  Some things that sounded or looked simple in the conceptualizing stages were complicated to implement in code, and it also turned out to be simple to implement some seemingly complex concepts / behaviors. For example, It was very easy to populate an array with lines. It was also easy to create a line object. Probably one of my favorite things talked about in a discussion in conference was about the point or goal of our class, which is to enable students to see visual work and feel encouraged and confident to be able to replicate it in code, or to execute one of their own imagined ideas.

For starters: I was not able to get as much visible interactivity in my system as I had hoped. In some ways, it still looks random. And in other ways, it does not look random enough. Some of this has to do with how many exact rules are turned on at a given time. Being able to set a randomSeed and to toggle the frameRate of my system have been very helpful, because it has allowed me to see what would happen to my system over time in more controlled settings. Even with all the rules turned on at once, it is easy to see with accelerated frameRate that my system seems to fall back into a mostly regular loop. That does not mean that it is not mesmerizing to look at – it definitely is, especially when you realize it is a simple system of only Line objects.

My class suggested writing my system with a randomSeed in place. This also turned out to be a lot easier than I expected or was familiar with from my previous coding experiences.

For randomSeed, I had to learn that a random number generator essentially is “only random on the outside”: inside, it deterministically creates numbers based on the given seed. So the specific sequence of numbers that it will return from the seed ’99’ is always the exact same sequence, regardless of how many times we run it. That’s why it’s called the ‘seed': ALL of the randomness grows out of just that initial seed, like how an entire tree grows out of a seed.

I will definitely continue to work on my sketch, specifically in trying to make interaction and gradualism more apparent.

Modulated Synthesis

My attitude towards this assignment was radically different from my attitude towards the previous assignment. I was inspired by our classroom experiments in combining both for-loops and the mod function. I was also inspired by Josef Albers’ usage of colors and tiling to make a statement about both shape and color. The for-loop and mod functions lend themselves to accomplishing something similar to Albers’ goals. sample of Albers' work I spent several hours just experimenting with different shapes, colors, and insertions of randomness and determination in my code. At first I had a background with ellipses that moved within columns, remained similar colors, and seemed to shimmer (due to the addition of an overlay of darker ellipses floating through the screen.) This really reminded me of my childhood bedroom, which had a beaded curtain over the doorway and a shimmer curtain by the window. It seemed like I had created a synthesis of the two.
Screen Shot 2017-10-26 at 12.08.07 AM

first experiments

I decided to experiment with the circular motion assignments we were given in class, while still utilizing the color scheme and grid concepts I had established in my first sketch. This way, I was able to get a band of ellipses radiating in a circular way from a central foci. And I was even able to control the color of the ellipses, depending on where in the grid they were falling into.
Screen Shot 2017-10-29 at 6.56.56 PM

adding a JS object that utilizes circular motion

I realized that where the horizontal bands and vertical bands intersected, I got an unpredictably cool pattern, so I decided to have the bands overlap uniformly. While doing this, I realized I could modify the color (again, using mod, hence producing a gradient.) The circular_circles object remained in this iteration of the code, but I realized that it was aesthetically unpleasant to have 2 radically different shapes (ellipses and rects) overlap in an non-meaningful way.
Screen Shot 2017-10-29 at 7.06.40 PM

inserting a tiled background

So, for the moment, I forwent the inclusion of the circular-circles and instead played with the tiling background more. I added another function to my tile constructor, that allowed the gradient itself to change over time. And, through experimentation, I was able to have it so that the manner in which the gradient changed mimicked tiling itself. The picture below demonstrates multiple quadrants of graduated tiling. At this point in the process, I thought my work resembled a bit of Mondrian’s work, because of the juxtaposition of differently-colored ’tiles’. It especially resembled the work of other students’ in the class after they completed the animated Mondrian assignment. Screen Shot 2017-10-31 at 12.18.10 AMAt this point, the fact that the assignment encourages using a JS object that has a parameter passed through it, I decided to abstract even the size of the tiles. Below is an image showing the result of modifying the size of the tiles. At this point, the repetitive element determined by the dark-purple background is completely omitted, which has its own implications. I think this is beautiful and smooth in its own right; but I did appreciate the repetitive nature of the purple color, as it gives the entire wallpaper its own sense of continuity.
changing the size of the tiles

changing the size of the tiles after adding changing colors to the tiles

Since I was not so pleased with this outcome, I decided to re-introduce the circular motion aspect into the tiles I decided I had liked, except instead of using ellipses, I used rectangles (as this would better fit with the current scheme.) This is my final product for now, but I could definitely use revisions. And with better understanding of coding, I could do a lot more.
final product for now

current “final”

Hole in the Sky

Already having been behind in Art from Code, I realized that my outlook towards this assignment stipulated an effective strategy. After talking with some people, I decided to try to capture a poem that I had already written in the form of a collage. Poetry naturally contains a lot of contradictory and sometimes overlapping images, motifs, and concepts. I first started by simply gathering all my images, taking suggestions from my poem, and putting them down on a canvas.
Screen Shot 2017-10-07 at 10.56.52 PM

Using push(), pop(), and translate() to simply get images down on the canvas.

I then moved some of the images around to be more compositionally pleasing, and tried to incorporate more of the requirements to the prompt by utilizing the rotate methods and also starting to add text from the poem – focusing on reiterating the central symbols. The translate method was extremely useful in helping me work through revisions as I changed the placement of images.
adding rotation

adding rotation and text from the poem

After adding some more text, I began to use the arrow shown in Chapter 3 of Make as it is an example of a vertex drawing.
adding arrows

adding arrows

I quickly realized that arrows were not actually what I wanted. When I think of collage, or my experiences with collage, I am reminded heavily of using tape. So I decided to make several ‘tape’ pieces. But I think playing with the alpha channel of each of these pieces of tape was fun. The tape elements remain fixed in the canvas, whereas the three images behind it are animated to center-rotate. I think the fact that these pieces of tape remain fixed is a cool reference to antiquated practices of collage.
pieces of tape

pieces of tape

I added the sound elements of: waves breaking, the apollo moon landing, and a dog howling. I also applied the collage idea to my usage of sound, by having the sounds all play at once, but at different relative volumes, if the mouse is clicked. Poems are sort of like dreams or are a literary method where several related images are interwoven. I think collage might conceptually allow something similar to happen. For reference, the inspirational poem can be found here. In retrospect, I think I would have liked to learn how to resize images within the p5.js library itself, if possible. Making a collage is difficult; it is hard to make the images cohere or speak to one another. My final result does not satiate my own expectations. While it contains vector graphics, sound, rotation, animated rotation, text, colors (though only within a contained palette), and fonts, this piece seems still too disorganized for me. And I am afraid that it may not be very accessible to others.