Category: Uncategorized

vikz-02-Reading

1A) Effective Complexity

Nature and biological life are systems that serve as exemplars to effective complexity, and so dandelions were what first came to my mind as one of my favorite instances of such. On the spectrum, I believe dandelions fall within an equal split between relative order and randomnesses, which is why I feel particularly drawn these weeds, as I am fascinated with the balance and similar distribution of both. Typically, dandelions can be associated with having extreme "randomness" -- pick up the flower, blow on it, and have the seeds scatter haphazardly over the field by dancing, lifting, and dipping from the wind. However, once each individual seed settles, there is a method to which biological processes will take place from there -- depending on the fertility of land, the seed will take root, germinate, bloom into flowers, and repurposed into white pappis with seeds at the end. Additionally, dandelions are capable of asexual reproduction, resulting in many identical flowers. Wind and/or other factors in nature then chaotically disperses of the seeds, and the cycle continues.

A dandelion as seen in three different phases.

1B) The problem of Meaning: Can and should generative art be about more than generative systems?

Generative art serves as a medium to help maximize the possibilities and skillsets of an artist. However, to this, arises the issue of whether or not the emphasis should be placed on the "generative" or "art" aspect. Some projects call for attention to be drawn to the multiple iterative art pieces as the final product (with little regards to the process in which went about creating them; a top down approach), whereas others highlight the system of creating generative art (with little regards to the byproduct itself; a bottom up approach). Although there lies value in both approaches, I find myself personally aligning with the values of bottom up. Typically, when I finalize my mind on exactly what an end desirable should exhibit, I find myself more "comfortable", in the sense that I have a working goal in mind and am more so simply seeking the bridges to connect me to that. Whereas, when I work from a bottom up approach, I find it more rewarding to "seek truth to process as being inartistically beautiful", which not only celebrate creation as an activity, but also allows me to maintain an open mindset, and ultimately, design and create emotionally durable experiences.

 

vikz-LookingOutwards02

Face Trade is a vending machine of sorts -- cash in a portrait mugshot of yourself (taken on the spot at site), in return for receiving a computer generated face drawing. Your mugshot that Face Trade receives will then be permanently stored in the Ethereum Blockchain, therefore suggesting the exchange of a "semi-permanent" face-swap. The Face Trade project is comprised of a printer, thermal printer, buttons, lcd screens, speakers, cameras, flash, MDF, steel, paint, computer, and website. There is no information as to how Moka has decided the algorithm to which produces the unique generated portraits, and it is also not explicitly stated if there is a a feedback mechanism to which the mugshots help generate the unique portraits. However, I would think that there would be some sort of initial face detection code to pinpoint key components of a face (two eyes, a nose, a mouth, etc.), and then a library to which these faces would be generated from. From this, I suspect that there could be a machine learning element in which new mugshots retrieved could play a significant role in generating new eyes, noses, and so on and so forth.

I enjoy this project because of the union of inputting a personal stake and receiving an unique surprise. Moka "often trades control in favor of surprise" because of his belief of computation as an expressive tool. The effective complexity of this project is 50% balanced order and 50% disorder - the user has half of the power to generate the end deliverable; they have the complete choice to input whether or not they want to "cash in" and the deliverable (an unique portrait), however, they have no say as to how their mugshot will be used thereafter and what their unique portrait will look like.

Face Trade (2018) by Matthias Dorfelt (Moka)

Link: https://www.mokafolio.de/works/FaceTrade 

vikz-Interruptions

https://editor.p5js.org/vikz/sketches/m1kfW1x7c 

Observations:

  1. The artwork fits within a square
  2. Black lines on white background
  3. Lines are of same length and thickness
  4. Lines are placed at varying angles
  5. There is an overall flow to the image (having majority lines flowing either upwards/downwards, or flowing left/right
  6. Most lines are either touching one another or intersecting
  7. Lines near areas of negative space can be found to not touching other lines
  8. Many areas have repetitive lines "patterns" of some sort, with slight change of angle from one line to the next.
  9. Negative spaces between normal touching lines have relative similar area.
  10. There are random patches of absence of lines ("interruptions")
  11. Negative spaces "interruptions" are no more than 30% of the space.
  12. There are almost "columns" / "rows"; each line going down and across seem to have the same center point
  13. Amount of lines in each "column" / "row" ranges from roughly 45-55 lines.

Process: Originally, I had wrote three main functions (one to generate the lines themselves, one to generate a grid for which these lines would be placed, and one for calculating random holes based on noise(), to which I would then use in regards to the grid + line functions. I had run into several issues with this way, as I struggled manipulating each individual line to rotate in more "random" ways - it came down to either rotating all the lines at once, or rotating the entire canvas. I then decided to build off of Dan Shiffman's Coding Challenge #24, to which the manipulation of identical length lines were achieved through creation of a vector variable (p5.vector.fromAngle), to which he was then able to manipulate solely the vector itself by calling a rotation directly onto the vector, rather than the entire canvas. Then, through a noise function, I was able to achieve allotting "holes", or gaps in the canvas.

Although Dan Shiffman's way was very neat in achieving a series of segmented lines, I would have been more satisfied if I were to have the time to debug my own separate three functions. I believe that I would be able to achieve similar results if I could translate the way I drew lines by calling a vector, and then directly calling onto the vector to call for a rotation.

ilovit-Reading02

A

Novels are effectively complex. The elements of a novel are ordered by various structures of language, but still various. Letters are arranged into words, but the particular words vary widely. Similarly, words are arranged into sentences and sentences into paragraphs, chapters. To someone who doesn't understand the language, a novel seems almost like total randomness, but the rules of spelling, grammar, and narrative introduce an element of order.

B

The Problem of Uniqueness: I often have a certain reaction to a lot of generative art. When generative art creates infinite variations on something, each individual thing seems to lose its impact. You end up going "cool" then moving on. I feel like the stuff that works for me is when the objects generated are not presented as the main event. The generating system is the unique object with the unique experience.

ilovit-Interruptions

Observations:

  1. The artwork is square.
  2. The artwork consists of many short black lines, on a white background.
  3. The lines all have the same length.
  4. The lines directions vary
  5. The lines tend vertical
  6. The lines are in a grid
  7. The grid is interrupted intermittently by white space
  8. The interruptions tend to group in larger blobs
  9. The distances between the centers of the lines is half the length of the lines
  10. The grid is 56x56
  11. The lines are thin and black
  12. The background is white

Interruptions Recode:

https://editor.p5js.org/ilovit/sketches/xFpvWLjAW

Reproducing the shape of the work was easy. I got the lines the right length and at the right intervals pretty quickly, and once some random element was introduced to the angles, the picture looked very reminiscent of Molnar's work. figuring out that I should use Gaussian distribution to get the lines pointing mostly vertically but still randomly also took a short amount of time. However, the titular interruptions were very difficult to reproduce and I don't think I quite succeeded. I tried to create the interruptions using just the random function. My method was thus: I had each line look at the lines around it to decide how likely it was to disappear, then I spent a really long time futzing with the various numbers to try to get it to look a little more like Molnar's piece.

MoMar – Reading02

Cities that have been around since the middle ages are prime examples of effective complexity. In the olden days, urban planning was not widely used so people typically built buildings where they wanted to. On the scale between total randomness and total order, it's around the middle because as time progresses, the city gets more organized. There is a clear division between the two with the wide road surrounding the old city.

 


Zapra – Interruptions

View code

Observations / Assumptions:
  1. The image is a white square with black lines
  2. There are many short lines of the same size
  3. There are seemingly random gaps in the lines
  4. The lines form a matrix of rows and columns
  5. The lines are centered around a midpoint of equal distances apart
  6. Most lines are angled left or right, but have a slight proclivity towards the vertical
  7. There are often several gaps in the image of different sizes
  8. Some gaps extend or go over the edge of the grid
  9. There are about 60 lines in each row
  10. The space between each row is less than the length of the lines (if all lines were vertical, they would overlap about halfway)
Reflection

Some of frustration I ran into with this project was based off an incorrect assumption I made about how the lines were drawn. I had assumed all the lines were spaced equally based on the top endpoint rather than middle. Once I realized this, I struggled to find an effective way to center all the points around these midpoints (but once I did, I audibly yelled "YES!" alone in my apartment and gave myself a high five). I haven't done much in-depth coding since last year, so as I've progressed with this assignment I'm starting to remember more and more. I think ideally I could still tidy up my code, but I at least feel satisfied with the end result.

Some previous versions:

lubar – Interruptions

Observations:

  1. The artwork is a square
  2. The centers of each line segment are in a grid form
  3. The line segments appear randomly rotated
  4. The line segments occasionally intercept
  5. There appear to be 57 possible lines across each axis
  6. The piece has a blank margin
  7. There are clusters of blank spaces that appear in random locations
  8. The clusters of black spaces are not uniform in size or shape
  9. The length of each line is slightly less the double the distance between each line
  10. The lines are thin and short

Interruptions Sketch Link

In the process of creating this, I found the rotation of the line segments to be particularly frustrating, although I initially assumes that that would pose the least challenges. The method that I was using involved the rotate() and translate() functions and it took me a while to figure out to use multiple translations I needed push() and pop(). Overall however, especially after discussing Perlin noise a bit with Sophia, I found the other elements to run smoothly, although not perfectly when compared with the original pieces. Molnar's original interruptions have a slightly 'free-er' quality that I was not able to capture despite playing around with it for a long time. Despite the slightly denser interruptions, I am content with how the reproduction turned out, and I would be curious to know how that effect was/might have been achieved without Perlin noise, as I haven't quite been able to wrap my head around it yet.

 

 

vingu – Interruptions

link

observations:

  1. the artwork is square
  2. margin around the piece
  3. composed of a grid, around 56 by 56
  4. short black lines of same length
  5. the lines overlap around 1/2 of another line
  6. lines are rotated "randomly"
  7. there is either a vertical or horizontal grain
  8. some holes/ missing lines
  9. the holes are clustered together
  10. around 60% lines

For this piece, I started with a nested for loop to create a grid of lines. In order to replicate the rotations and clustered holes/missing lines, I learned about Perlin noise. It was challenging for me to understand Perlin noise; the main thing I got was that it was a "natural ordered, harmonic succession of numbers".  (it's more smooth, therefore can create "clusters"?) I spent a lot of time on the trigonometry of the lines given the random angle. Then I tested out Perlin noise syntax to see what worked/not. I used a x-offset for random rotation, and another x-offset2 for clustered holes (different offset maps it to different parts of the noise wave). I used a random conditional statement to determine whether it was horizontal or vertical grain (they used different line equations; the sin and cos were switched).  Then I added a noiseSeed() to generate different results every time it is clicked.

I found it difficult to replicate the rotation of the lines. My lines stay close to the grain, while Molnar's lines are more varied. I tried to test different numbers, but the lines ended up too varied and lost the "grain" effect. Molnar's rotation of the lines made the clustered holes stand out more. I admire Molnar's calculated randomness.(also she created this before before perlin noise was created)

clox-Interruptions

02-Interruptions

https://editor.p5js.org/clox/full/fmhoz0-qa

 

 

 

 

 

 

 

 

 

 

 

 

Process:

  1. First I observed the components of the original piece:
    1. uniform black lines distributed across a grid at their midpoint
    2. lines appear to rotate randomly around their midpoint
    3. lines are not always drawn
    4. the gaps in the line grid cluster
  2. Then I tried to break down each observation into steps to recreate this piece
    1. Made a looping function that defines the coordinates of the midpoints for each line
    2. Made a class for drawing a line
    3. Specified the attributes of that line making class:
      1. the line's midpoint
      2. the line's angle (randomly generated)
      3. the line's (ax,ay) and (bx,by) coordinates (calculated using angle and midpoint)
    4. Made a threshold for drawing a line (or not) using Perlin noise function in the for loop that draws the line by calling the line object
      1. I multiplied the Perlin noise value by 0.01 to amplify it
      2. I then chose a threshold that dictates whether a line should be drawn
    5. Finally I used the mousePressed function to refresh the canvas after a click