September 2019 – [OLD FALL 2019] 15-104 • Introduction to Computing for Creative Practice

Hyejo Seo – Looking Outwards – 06

Kenneth Martin was an English painter and sculptor – most importantly, he was an abstract artist. Kenneth focused on geometric abstraction, therefore, for his Chance and Order series, he utilized randomness to create geometric abstraction. “Chance” in this series refers to the combination of chance events, and the “Order” refers to the order of his procedures to create this series of paintings. His process was: (1) mark the canvas with points, moving clockwise around a rectangle (2) he had a bag full of pieces of paper with different numbers written. So, he would pick one pair of numbers (2 pieces of paper) and generated lines, following those two coordinates. (3) after doing this process once, he rotated the canvas clockwise, and repeated the process. This was a way of him attempting to be as random as he possibly could. One might say that this was not purely random since he was the one who wrote the numbers down on each piece of paper, but, in my opinion, combinations were what made each painting different, so it was the most random one could have been.

Even famous paintings that are prominent in abstract art period weren’t created truly by “random”. Each shape was usually placed by the artists, which is not random at all. This is why Kenneth’s works stood out. Although his process of creating geometrically random art was more “random” per se, but, somehow, these random lines create visual harmonies. It is nothing unsettling on the eyes to look at. I think part of the reason why this is possible is because he limited the number of colors to only two. Overall, Kenneth’s process of creating these “random” art was interesting to learn about, and his paintings are so simple, yet eye-catching.

Chance, Order, Change 6 (Black) 1978-9 Kenneth Martin 1905-1984

Timothy Liu — Looking Outwards — 06

“*Spectrum Colors Arranged by Chance I*,” as created by Ellsworth Kelly in 1951. Kelly used colored squares and wove them into his tapestries.

For this week’s Looking Outwards, I observed Spectrum Colors Arranged by Chance I, a work by Ellsworth Kelly from 1951. At first glance, the piece seems playful yet confusing; it’s essentially a two-panel collage of coated and uncoated colored squares with no discernible pattern. But when you stop to break down Kelly’s genius, it’s clear that there isn’t meant to be any pattern. That’s why the piece is proclaimed to be “arranged by chance”: Kelly literally cut up individual colored squares and sorted them as randomly as possible based on the grid he defined underneath.

Kelly at the time was undergoing a stylistic shift in his art style, moving from figuration to abstraction. To Kelly, “abstraction” meant randomness, which is why he set about making this collage of cut-up pieces from his colored drawings. To the naked eye, he seems to have been immensely successful, as it’s almost impossible to pick out any color pattern in his work. However, it’s important to note that Kelly was human, which meant that his work could not have been truly random. According to the Philadelphia Museum of Art, Kelly simply placed the colored squares “quickly and intuitively” on the grid without much thought. That said, humans are inherently subject to cognitive influences that cause us to act in certain ways; it’s very likely that Kelly placed a few squares in spots he thought were random, but were actually influenced by the presence of other color squares.

Only a computer program can get close to pure randomness; many functions, including random(), allow a user to call a random value from a range. But even computers can’t be fully random, as they are built from human models of information and randomness! Unless we feed computers all of the information in the world to use as data, they’ll never be truly random. That said, this is slowly changing with the rise of AI/ML, and it’s likely much more possible now for a machine to draw a random work of art on its own. I would love to see a random, computerized version of “Spectrum Colors Arranged by Chance I.” It seems like it would be difficult to identify differences between Kelly’s work and a computer’s, but perhaps there’s an algorithm or program that could determine that too!

Sources:

https://www.philamuseum.org/collections/permanent/295539.html

https://geometrica.tumblr.com/post/464581306/ellsworth-kelly-spectrum-colors-arranged-by

Chelsea Fan-Looking Outward-06

Andrej Bauer started a Random Art Project that generates expression trees that describe an image. An interesting part of his random art is the functions he uses. He does not use a generation algorithm to create his artwork.

His website for his artwork allows viewers to rate the artwork and sort the pieces by popularity.

I admire that Bauer creates an abundance of different pieces. His artwork has a specific”style” that really represents “Andrej Bauer Art”. Because the pieces are so different and diverse, yet still similar through the style, viewers can tell a certain piece is created by Bauer. One critique I have is that his website is fairly limited and doesn’t reach a wide audience of people.

Andrej Bauer Doubledown Hoobris Piece (n.d.)

Sewon Park – LO – 06

Abstract Art drawn by the Random Number Generator designed and created by Larry Cotton (2017)

One interesting piece of art that utilized randomness is the RNG abstract art by Larry Cotton. Designing an algorithm that creates random art can be rather difficult to create. Although using random digits to dictate aspects of art such as size or color may not be too difficult using programs such as p5.js, Cotton has designed a machine that uses such algorithm to directly paint on the painting.

The machine is linked directly to the t-shaped glass panel that controls the stroke of the pen

The machine is linked directly to a computer where Cotton programs it to use random numbers to dictate color and pen stroke. In order to put some structure to the randomness, the user can dictate a certain range for the variables. As a Carnegie Mellon student, obviously I have heavy interest in engineering and other STEM subjects. As such, seeing an effective use of machinery to create abstract art was very inspiring.

Draw Abstract Art with a Random Number Generator

Alec Albright – Looking Outwards – 06

Cage's 'Dereau (#11),' 1982 — Cage’s “Dereau #11”, created in 1982

Above is John Cage’s “Dereau #11”, which he created in 1982 as a part of his visual chance art. The randomness was implemented in this work through several aspects. First, once a shape had been selected to be drawn, the quadrant in which it was drawn was randomly selected. Then, the color of the object appears alone or in combination with one of forty-five colors in chance-determined percentages with or without white. This work is admirable to me because it seems to follow no structure, but the procedure behind it is fairly well-defined. This piece could have turned out in an endless number of ways, and the odds of this exact work being created through his defined mechanism again are infinitely slim.

Sydney Salamy: Looking Outwards-06

The work is called Schotter (Gravel Stones) by Georg Nees, created in 1966. It is a vertical piece with a slightly tilted rectangle made of little clear squares that slowly separates and comes apart as the viewer looks further down it. It was meant to show the effects of change and relationship between order and disorder.

I really like the simplicity of the piece. It’s hard to explain why, I just like how Nees was able to do what he did with so little. I also like how despite the simplicity, he was able to still convey his message about order developing into disorder and vice versa (depending how the viewer looks at it). A lot of times, art this simple, if it has any meaning at all, tends to be very obscure, leaving it all up to the viewer. Here, the piece is still simple and leaves some interpretation, but there is still pretty clear intention and meaning behind it.

According to Media Art Net, the piece was produced by the programming language ALGOL, and was created by random generators. It was made by “invoking the SERIE procedure” (which controls the composition process), with the “non-parametric procedure QUAD”. QUAD is located in lines four through 15 of the generator and generates the squares with constant lengths and random locations along with varying angles. The position of the squares at certain points are influenced by random generators, such as J1, and the angles by J2. Counter index 1, invoked by each QUAD call, controls the “successively increasing variation between the relative coordinates P and Q, and the angle position PSI of a given square…” So essentially, Nees had influence over his work, creating an outline for what it would look like, but the end result was left up to the pseudo-random numbers.

Georg Nees is considered a founder of computer art and graphics. He seemed to experiment with what he was given, using languages like ALGOL, made for scientific computers, to create his works. He experimented quite a bit with random numbers. A lot of his work seemed to involve basic clear shapes and/or lines, along with a little pseudo-randomness. This can all be seen in Schotter, since the shapes being used are simple squares, and there is a bit of randomness to things like their placement and angles.

Art with lots of squares by Georg Nees — Schotter By Georg Nees

Ellan Suder Looking Outwards-06

random-art.org by Andrej Bauer generates individual images for user-inputted phrases. “The program accepts the name of a picture and uses it as a seed from which a picture is generated randomly. The same name always yields the same picture.”

It’s a fun, interactive artwork. The inclusion of the gallery where people can submit the images they’ve generated are really interesting because you can see all the different phrases people think of while they experiment with the generator. If you sort the gallery by popular, you can see the images voted ‘most interesting’ — one that I found most interesting was ‘sand dunes’, which by chance generated an image that looked like sand dunes.

I created a few myself:

Here is the artist’s explanation for how the code (Python) works:

The idea is to generate expression trees that describe an image. For each point `(x,y)` of the image we evaluate the expression and get a color. A color is represented as a triple `(r,g,b)` where the red, green, blue components are numbers between `-1` and `1`. In computer graphics it is more usual to use the range `[0,1]`, but since many operations are symmetric with respect to the origin it is more convenient to use the interval `[-1,1]`. I kept the program as simple as possible, and independent of any non-standard Python libraries.

If I changed anything about the project, I would like to see how each inputted word gets broken down and turned into an image.

Joseph Zhang – Looking Outwards – 06

A few weeks ago, I was looking into the practice of computational design and found Brute Wine, a wine company in Hamburg that uses the wind patterns in the city to craft the brand’s designs. The brand concept was developed by an international creative studio called Landor. In their case study of this project, they state “The weather shapes the wine, we used it to shape the brand.”

In the image above, one can see the live weather statistics pulled from Hamburg. Because weather is constantly changing on a daily basis, every daily visit to the site yields a completely new visualization.

Brute Wine manifests the data-driven designs in various ways, such as mobile/desktop interfaces, posters, and of course, on their physically branded products.

One can see the designer’s artistic choices come to life from 1) the beautiful forms themselves and 2) the beautiful color palette as seen here. Brute Wine’s uniqueness comes from the fact the wine is grown in rough weather conditions. This is very beautifully demonstrated in the color dimmed whites and dark blues.

/www.brute-wine.com/

Fallon Creech-Project-05-Wallpaper

sketch

//Fallon Creech
//Section B
//fcreech@andrew.cmu.edu
//Project-05

var x = 40;

function setup() {
	createCanvas(560, 560);
}

function draw() {
	background(220);
	noStroke();
	for (var i = 0; i < 15; i++) {
		for (var j = 0; j < 15; j++) {
      //fill every other column with all orange ellipses
			if (j % 2 == 0) {
				r = 245;
				g = 125;
				b = 0;
      }

      //fill every other column with orange circles in every other row
      else if (i % 2 == 0) {
				r = 255;
				g = 165;
				b = 0;
			}

      //fill every other column with purple circles in every other row
      else if (j == j) {
				r = 50;
				g = 80;
				b = 220;
				fill(r, g, b);
				rect(x * j, x * i, x, x);
			}

			fill(r, g, b);
			ellipse(x * j, x * i, x, x);
		}
	}
}

I chose to approach this project as an extension of the assignments we worked on in lab, so I created a pattern of circles that used color to differentiate between row and column with one circle that adopted another quality.

Nawon Choi— Project 05 Wallpaper

nawon-05

// Nawon Choi
// nawonc@andrew.cmu.edu
// Section C

function setup() {
    createCanvas(440, 540);
    background("white");
    stroke("white");
    for (var y = 0; y < height + 20; y += 110) {
        for (var x = 0; x < width + 20; x += 110) {
            // background triangles
            fill(y/2, x/2, 200);
            triangle(x, y, x, y + 100, x + 50, y + 50);
            fill(y/2, x/2, 180);
            triangle(x, y, x + 100, y, x + 100, y + 100);
            // center circle
            fill(y/2, x/2, 250);
            ellipse(x + 50, y + 50, 25, 25);
            fill(y/2, x/2, 220);
            triangle(x, y + 100, x + 50, y + 50, x + 100, y + 100);
            fill("white");
            ellipse(x + 50, y + 25, 5, 5);
            // bottom triangles
            fill(y/2, x/2, 250);
            triangle(x + 50, y + 50, x, y + 100, x + 33, y + 100);
            fill(y / 3, x / 3, 150);
            triangle(x + 50, y + 50, x + 33, y + 100, x + 66, y + 100);
        }
    }
    noLoop();
}

function draw() {
    // draw is not called due to noLoop() in setup()
}

For this project, I was inspired by geometric shapes, as well as the color gradient that we learned how to code during lab. I tried to create a small landscape image through the composition of my geometric elements. I like the way the that the gradient adds to the wallpaper by the way it alludes to a sunset or sunrise, and the way the colors of the sky change.

I sketched out a couple different ideas that I tested in p5.js, and ultimately decided on one that looked the best compositionally. I found that a lot of the other iterations had too many elements which was overwhelming to the eye.