Ass­i­g­n­m­e­n­t #1

by Sarah Shultz

DESIGN BRIEF

When thinking about generative art and design for printing on merchandise such as t-shirts, shoes, canvas bags, and so forth, I immediately knew that I wanted to make a simple, yet still customizable design. Creating a sketch that can have a lot of variability but still be 'branded', is essential marketing that would make a design become popular since it would be unique and similar at the same time. Upon the two design themes I choose 'balance and harmony' to create a design that could be used on clothing, postcards, and even just simply posters!

INSPIRATION

In the beginning I was completely stuck because I had no clue where to find inspiration from, creativity is not something that comes easy to me. But slowly I started to get an idea in my head after reviewing the tutorials. I really loved learning about the noise function within Tutorial Six. I have always leaned towards using the random function in weekly tutorials, but I always thought sometimes they can be too harsh and jarring, so discovering a 'more controllable way to create unexpected values' was perfect. The history behind the noise function is also quite interesting and matched my desire to create a smoother, more natural flowing design. Thanks to Ken Perlin and the Perlin Noise technique, I really fell in love with the noise function containing two parameters that create 2D textures. It is here where I knew I wanted to do something with a 2D textured noise background.

Originally I had wanted to create an ‘ocean-like’ theme that combined gradients of blues, greens, and whites that would change in variation with each iteration. But unfortunately due to my habit of always starting with a big picture instead of a little one, I did not realize how hard that was. Unfortunately I was nnt able to figure out how to change the colour of the textured background in time but instead it all worked out because I ended up creating a fun geometric animal with varying colours!

The idea to create a simple geometric animal came along as I was coding the background, just brainstorming what would look simple, yet aesthetically pleasing. I also really happen to love animals and simple, minimalistic designs, so everything fell right into place. Inspiration and a guide more importantly, on how to draw a geometric animal came with a lot of Google searching and eventually I came across a ‘simple’ enough animal that seemed fun to draw – a flamingo! There were really only two shapes involved that didn’t have any super complicated angles like a rhombus or irregular quadrilateral. And together with a circle, square or triangle framing the animal, I thought that the design was simple, yet still extremely variable because of the randomness in each part of the design. The randomness is subtle because I wanted to stick to the theme of .balance and harmony..

PROCESS

The process of creating my design was tedious but very rewarding. In the beginning I put too much on my plate and wanted to create a gradient ocean texture background, but after much frustration I decided to stick with a dark grey 'cloudy' background that would serve as a great contrasting backdrop to my foreground elements. Each design element came together as I was coding and was not acutely planned from the very start.

The first sketch I mainly focused on selecting how dark I wanted my grey background to be and how ‘smooth’ or ‘noisy’ I wanted the texture to be. This was tested through adjusting the greyscale number and the increment variable. Following I decided to start creating a geometric animal that was much, much harder to create than I had originally planned. Aligning each shape perfectly in reference to one another was tedious but still fun. Originally I decided to alternate colours between each shape that had sides touching another because it was just easier to plot points, but after the flamingo was finished I realized I really liked the variation of colours between white and the original bright purple I had used. The third sketch involved creating the variability and 'uniqueness' to the piece so that each one would be completely different from the rest!

Along with using a nested for-loop to create a background, I mostly used if-statements to dictate which option chosen at random would be displayed on the screen. The combination between the random function and if statements applied to each part of the design, the variety in design in each iteration is unique. While the variation may seem 'too subtle' I think this is what makes it a good design because the each variation isn’t hugely contrasting from the next, at least not at once. Instead I focused on creating simple elements that can be found in a variety of colours, shapes, and thicknesses. Below I have listed each component of the design that has variability.

  1. The background has a noise range between 60 and 65, thus creating subtle, but still different 'cloudy backdrops'
  2. The flamingo is separated into white and coloured shapes
  3. The white shapes can either be set to fill or noFill
  4. The colour shapes can either be set to fill or noFill
  5. These two options are independent form each other so that there Is four options of variability just within the shapes themselves
  6. The coloured shapes of the flamingo is generated randomly, covering the entire rgb colour spectrum
  7. There are three shapes, either a circle, square or a triangle that surrounds the flamingo
  8. The circle and triangle both have randomly selected stroke weights (between 1 and 10) and colours

Combined, the possibilities for a unique design is infinite!

THE FUTURE

For the future I would create more geometric animals that could be randomly generated for even more customization. I would also learn how to finally create a coloured textured background that could then have gradients, solid colours, and more applied to the background. I also would want to learn how to store shapes into arrays to make it easier to change and reference each shape. Overall, the possibilities are endless and I really enjoyed creating this project.

REFERENCES

Processing.Processing. Available at:Â https://processing.org/. [Accessed 10 April 2016].

  • Show Sketch
/** @peep sketchcode */
 
// GLOBAL VARIABLES: they have to be global so they can be accsessed by all functions
 
// this is for the noise() function
float increment = random(.005, .03); //the smaller the number, the smoother it gets
 
/*
Ihe two variables below must be seperate because each one generates a random
number for either all of the coloured shapes that make up the flamingo, 
or all of the white colored shapes. If I had combined them into one variable,
then all of the shapes would be filled at the same time in their respective colours,
or all of the shapes wouldn't be filled at the same time. By creating two variables,
I created more variation since the coloured and the white shapes are independent from each other.
*/
float fillWhite = random (1,4);
float fillColour = random(1,4);
 
/* 
I wanted to always keep the colour white as a 'balancing and harmoning' color,
because if there were too many random colours creating the flamingo, the drawing overall
would look too busy and messy. By always having one stable colour that goes well with any other (white),
the piece always has complimentary 'colour schemes', thus avoiding the risk of colours like brown and yellow
being paired togehter.
*/
color white = color (255);
color randomColour = color (random(255), random(255), random (255));
 
/*
Here are the two variables for choosing a random colour for the shapes outlining the flamingo and 
for creating a generator of random numbers between 0-4 to decide between either a triangle, square,
or a circle to outline the flamingo.
*/
color randomColourShapes = color (random(255), random(255), random(255));
float randomShape = random (0,6); 
 
 
/*
Call setup or 'main', where all of the other functions I have created
can be called and combiend all in the same place.
*/
void setup () {
  size(400, 400);
  backgroundTheme();
  shapes();
  flamingo();
} // end setup() function
/*
This function creates the background pattern. Here I used the noise function to 
create a nice dark grey, cloudy, 'abstract' foundation that would look nice 
with any other colour. I only created subtle variation within the background,
(a range of random numbers only between 60 and 65), because I liked the diffusion
results best with this small range of numbers. Any number too low or high would 
distract from the foreground pieces. If I had made the range too large, then there 
wouldn't be too much consistency and there would be a lot of unwanted background noise.
*/
 
void backgroundTheme () {
  //embedded for loop because i have to cross over the x and y axis to cover the entire window
  for (int y = 0; y < height; y++) { 
    for (int x = 0; x < width; x++) { 
      // create a variable that holds the noise function! 
      float greyBG = noise(x*increment, y*increment) * random (60, 65);
      // the lower the number between 0-255, the darker it goes 
      stroke(greyBG); 
      point(x, y);
    } // end inner for loop
  } // end outer for loop
} // end of backgroundTheme () function
 
/*
The shapes() function simply holds the triangle, square, and circle that is surronding
the flamingo. I thought a variation between these two shapes, appearing at random on 
each iteration would really bring attention to the flamingo! I didn't choose any other shapes,
just because they would not frame the flamingo well. There would be too much negative space and not 
support the 'balance and harmony' theme.
*/
void shapes () {
 
/* if statements were created to choose at random what shape (circle or triangle) would be 
displayed around the flamingo!
*/
 if (randomShape <= 2) {
    // CIRCLE
    noFill();
    strokeWeight(random(1,10));
    smooth();
    stroke(randomColourShapes); 
    ellipse(200, 200, 315, 315);
 
  } else if (randomShape <= 4) {
 
    // TRIANGLE
    noFill();
    strokeWeight(random(1,10));
    smooth();
    stroke(randomColourShapes);
    triangle(20, 50, 380, 50, 200, 375);
 
  } else if (randomShape <= 6) {
    // SQUARE
    noFill();
    strokeWeight(random(1,10));
    smooth();
    stroke(randomColourShapes); 
    quad(50, 50, 350, 50, 350, 350, 50, 350);
    }
 
}
 
/*
The flamingo() function was the hardest of all! After researching many 'simple'
geometric animals, I decided on the the flamingo because the placement of the triangles
and quadrilaterals seemed fair enough to code and position myself. I was wrong. It was 
pretty difficult drawing each shape in relation to each other but after awhile I got the 
hang of it and am happy that it actually does resemble a flamingo!
*/
 
void flamingo () {
 
    strokeWeight (1);
    /*
    Had to scale and translate everything because I originally drew the 
    flamingo too big,.on an 800 x 800 frame. BUT really learned how useful
    scale() and translate() can really be!
    */
    scale (.75);
    translate (75, 10);
 
    /*
    Used the push and pop matrix functions to seperate all of the coloured 
    shapes and the white shapes from each other. That way they can independently
    be randomly choosen on their colour and whether or not their shape will be filled.
    This allows for more variation in the piece.
    */
      pushMatrix();
        if ( fillColour <= 2) {
            fill(randomColour);
        } else if (fillColour <= 4) {
            noFill();
        } 
        stroke (randomColour);
        triangle(130,150, 150, 154, 143, 190);
 
        stroke (randomColour);
        triangle(140, 133, 180, 135, 165, 150);
 
        stroke (randomColour);
        triangle(141, 123, 160, 100, 180, 135);
 
        stroke (randomColour);
        triangle(175, 99, 200, 115, 180, 135);
 
        stroke (randomColour);
        quad(143, 240, 205, 155, 215, 155, 175, 236);
 
        stroke (randomColour);
        quad(143, 253, 175, 236, 181, 242, 187, 280);
 
        stroke (randomColour);
        triangle(187, 280, 190, 235, 220, 228);
 
        // butt
        stroke (randomColour);
        triangle(220, 228, 250, 230, 265, 277);
 
        // quad thigh
        stroke (randomColour);
        quad( 235, 320, 211, 280, 240, 280, 250, 320);
 
        stroke (randomColour);
        triangle(187, 280, 190, 235, 220, 228);
 
        stroke (randomColour);
        triangle (200, 430, 205, 295, 225, 305);
 
        stroke (randomColour);
        triangle (130, 353, 150, 336, 150, 345);
 
    popMatrix();
 
    pushMatrix();
 
        if ( fillWhite <= 2) {
            fill(white);
        } else if (fillWhite <= 4) {
            noFill();
        } 
 
        stroke (white);
        quad(130, 150, 140, 133, 165, 150, 150, 154);
 
        stroke (white);
        triangle(140, 133, 141, 123, 180, 135);
 
        stroke (white);
        triangle(160, 100, 175, 99, 180, 135);
 
        stroke (white);
        quad(180, 135, 200, 115, 215, 155, 205, 155);
 
        stroke (white);
        triangle(143, 253, 143, 240, 175, 236);
 
        stroke (white);
        triangle(187, 280, 181, 242, 190, 235);
 
        // equaliateral triangle
        stroke (white);
        triangle(187, 280, 220, 228, 265, 277);
 
        // tail,butt
        stroke (white);
        triangle(270, 285, 250, 230, 285 ,277);
 
        // tiny triangle
        stroke (white);
        triangle (243, 285, 240, 280, 250, 280);
 
        stroke (white);
        triangle(205, 295, 212, 285, 225, 305);
 
        stroke (white);
        quad(150, 345, 150, 336, 250, 320, 240, 335 );
 
   popMatrix();
 
}

Comments

Nobody has said anything yet.