Reading Reflection 1

Casey Reas ideology of art made me reevaluate my thought that art is something that should be consciously shaped by an artist. His concept makes me embrace the capabilities of letting the unknown unfold and curating it to become what one wants it to be and this is enough to be considered as creativity. I bared the thought that randomness in art is an accident but on viewing his catalogue of artwork I came to understand that randomness is an active and thoughtful way to come up with new possibilities in art. This has changed my view of artists ownership where an artists role is not reduced but rather redefined as someone who curates chance and thus expanding what is considered  art.

Ultimately, Reas discussion on randomness in art has impacted how I approach my creativity in art. The idea of using chance not as an afterthought but as a way of discovery creates more freedom in art. This has inspired me to take chance as an opportunity rather than a risk as in this way I become a collaborator with the unknown, guiding it to become something surprising yet deeply personal. This has consequently enlightened me that art is not just the outcome but rather everything from the imagination, process and implementation and it is not only what is planned but what comes out naturally through the process.

Assignment 2 – Looping in the Dunes

Concept

When thinking about what kind of loops and patterns I would like to code for my assignment, I had my ideas brainstormed from floral patterns to portraits created using loops. But, I decided to choose a loop concept stylistically resembling the Dune movie. Since, the movie and its style is very diverse and highly aesthetic, I thought it would present a great room for experimentation (and also I am just a fan of the Dune sequel).

Looking through a Pinterest board, I’ve identified main elements that I would implement in my project, which was the sun and the desert. It was also important for me to work on the colors of the design.

Since, the coded image of the Dune universe was not as realistic as in the movie, I decided to add a pop art element of kind of vintage picture of the scene. So, I additionally added loop of the points.

What I’m Proud of
//desert imitation & animation
 fill ('#ea941b')
 stroke('#dd691e');
 strokeWeight (1);
   
 for(let x=25;x<=550; x += 100){
   for (let y=190;y<=510; y += 15){
     if(mouseIsPressed){
       fill(238,159,28);
       arc(x,y,50,15,PI,0)
   }
     else {
       arc(x,y,50,15,0,PI);
     }
   }
 }
   
 for(let x=75;x<=550; x += 100){
   for (let y=190;y<=510; y += 15){
     if(mouseIsPressed){
       fill(216,99,29);
   arc(x,y,50,15,0,PI);
      } else {
       arc(x,y,50,15,PI,0)
     }
   }
 }

I’ve been struggling a lot with how to visualize the dunes in the code. After experimenting with the arcs, I switched from noFill arcs to filled ones, cause they looked more on point in the visuals. Moreover, I wanted to animate the arcs, so I used conditionals to create some difference in the forms and image of moving dunes in the desert. I feel like I could accomplish my vision, even though it took a lot of trials.

Sketch

Reflection

In the future development of this project, I would like to work more on the image of the dunes, to make them more realistic and appealing (so it would be easier to recognize theme of the Dune). I think this could be accomplished through Bezier curves or experimenting with another forms of arcs. Moreover, I would work on interactivity of the project, since even though it is now interactive in some way, I would like to focus specifically on resemblance of the desert environment, such as wind moving the sand or just the sunrise and the sunset. In addition, I think color scheme could be improved, by adding more gradients.

 

 

 

Assignment 2 – Interactive Mandala

Inspiration

For this assignment, the task was to make a simple work of art using loops. My first thought was that  I wanted to make something that resulted in a visually appealing pattern of some sort (with an element of interactivity as well). As I was brainstorming ideas, I scrolled through my Pinterest boards and came across various dot mandala designs. The intricate patterns and vibrant colours of these mandalas instantly caught my eye, inspiring me to create a digital version that would capture the same sense of symmetry and beauty. I wanted to explore this concept – an effect where symmetrical shapes radiate out from a center point, creating an interesting pattern.

Concept

The core concept behind my project is to also incorporate a kaleidoscope-like pattern that keeps rotating, creating a mesmerizing visual effect. I aimed to use symmetrical shapes (circles) and a gradient of colors to mimic the aesthetic of traditional mandala designs. To add an interactive element, I decided to map the number of segments to the horizontal position of the mouse, allowing viewers to alter the complexity of the pattern by simply moving their cursor. This interaction not only makes the art more engaging but also gives viewers control over the visual complexity, making each interaction unique.

Implementation

Here’s the final product!

I started by setting up a square canvas with a black background to make the colours stand out. The origin was moved to the center of the canvas to simplify the rotation and placement of symmetrical shapes. I used two nested loop to create the series of symmetrical shapes (circles in this case) radiating from the center. Each shape is rotated by an equal angle to maintain symmetry. The number of these symmetrical segments is dynamically adjusted based on the mouseX variable, adding interactivity.

Something I explored on my own was how to use the rotate function and incorporated it for two purposes in the artwork:

  • To rotate the entire canvas continuously over time, creating the overall animation effect of the whole mandala rotating.
background(0); // black background
  translate(width/2, height/2);  // moving origin to the center of the canvas (instead of top left corner)

  // Rotating the entire canvas to animate the mandala
  rotate(frameCount * 0.6);  // rotating by frameCount * 0.6 to make the animation and control speed (since frameCount increases with every iteration of the draw() function)
  • To manage the placement of individual symmetrical segments of the mandala.
// Mapping the mouseX position to the number of symmetrical segments (between 6 and 30)
  numShapes = int(map(mouseX, 0, width, 6, 30));
  // print(numShapes);

  let maxRadius = 250;  // max radius (distance from center of canvas till edge) for shapes

  // Loop to create symmetrical patterns
  for (let i = 0; i < numShapes; i++) {
    push(); // saving current drawing style settings and transformations
    rotate((360 / numShapes) * i);  // rotating each shape by equal angles

While working on this project, I also learned to use the map() function, which became necessary for adding dynamic and interactive elements. Initially, I found it challenging to map values between different ranges, but experimenting with map() helped me control aspects like the number of segments, shape sizes and color gradients. By mapping the mouse position to the number of segments, I could easily adjust the pattern’s complexity, and mapping distance to hue allowed for smooth color transitions.

Another thing I did differently was use the HSB (Hue, Saturation, Brightness) colour mode instead of traditional RGB values or HEX codes. This was mainly done to create the smooth gradient that changes as you go outwards in the mandala. By mapping the shapes’ distance from the center to the hue value, I achieved a transition in colour that adds to the overall visual appeal.

Reflections and Further Improvements

Working on this project taught me a great deal about the creative potential of code. It also deepened my understanding of how symmetry and rotation can turn simple elements into complex, visually appealing patterns. Beyond the technical skills, I discovered the importance of experimentation and iteration in the creative process, allowing me to refine my ideas to achieve the outcome I was looking for. For this project, I used circles to keep the design simple, but to achieve a more authentic mandala feel, I might want to incorporate other shapes of varying sizes in the future. This would add complexity and better mimic the intricate details often seen in traditional mandala designs. Overall, this project was a rewarding experience that broadened my perspective on combining art and coding.

Assignment 2: Fuzzy Brain

Concept:

In this project, I draw inspiration from the geometric artworks discussed in: COMPUTER_GRAPHICS_AND_ART_Aug1977.  My goal with this project was to explore the potential of ‘for’ loops to generate grids of symmetrical, curved lines, creating a structured, rhythmic design. However, I hoped to disrupt this symmetry by introducing heavy distortion, with the intention of simulating the visual effect of mind fog. The resulting artwork presents a uniform arrangement of curves that distort and displace when the cursor hovers over it, evoking a sense of disorientation and randomness—mirroring the feeling of brain fog.

Highlight:

I’m particularly proud of the distortion animation I added to this sketch. By utilizing the dist() function, I created interactive conditions that are activated when the mouse hovers over the Bézier curves. Using an if statement, I introduced random increments within a range of negative to positive values to the variables used as arguments for the original Bézier curves. This approach helped change the positions of the curve lines at random, adding distortion and creating the brain fog effect that I intended. Additionally, reducing the frame rate helped give the animation a 90’s cartoon effect aesthetic.

// mouse hover animation
    if (dist(mouseX, mouseY, x, y) < 300) {
      // displace lines randomly
      x1 += random(-20, 10);
      y1 += random(-30, 10);
      x2 += random(-40, 10);
      y2 += random(-50, 10);
      x3 += random(-60, 10);
      y3 += random(-70, 10);
      x4 += random(-80, 10);
      y4 += random(-90, 10);
    }
    
    bezier(x1, y1, x2, y2, x3, y3, x4, y4);

Reflections:

While working on this project, I experimented with creating symmetrical grids and distorting the curves to simulate mind fog. Initially, I focused on generating the grids using for loops, but as I introduced interaction through mouse hover effects, I realized how much potential this had to enhance the dynamic nature of the piece. The use of dist() and if() functions to trigger random distortions worked well in creating a more immersive experience.

Looking back, I think there’s room for improvement in making the distortions more fluid and gradual. Currently, the randomness of the distortions can feel abrupt, so in future iterations, I would explore using easing functions to smooth the transitions.

Reading Reflection – Week 2

I found myself enjoying Reas’s lecture quite a lot more than I thought, and a big part of that was the endless visual examples of works of art that he showed rather than told. It was interesting to see such diverse forms of art, and some pieces even made me question what art actually is. Some of the pieces honestly just looked like close up clumps of hair (3:08) or balls of lint (10:19). Maybe it was a bit too random for my personal liking. Overall, it was still really cool to see just how much randomness there was, which made me think of how different randomness would be when it comes to humans vs computers. Needing random numbers in our code would be easy work for a computer–(and it would actually be random), meanwhile if I was told to choose a bunch of random numbers, I would choose them based on numbers I like and numbers that are special to me. Since I would be more focused on the significance of the number rather than its randomness, it would end up not being very random.

Going back to computer randomness, I feel like I learned a lot more about the structured potential computers have at creating arts of randomness. Take for instance the black and white squares that changed color depending on heads or tails. It looked pretty alright being that random, but just by adding symmetry, it completely transformed the look of the art, and I enjoyed that a lot more than how it was before. It made me realize that just because it’s random doesn’t mean it has to be messy.

The overall concept of randomness and chance when it comes to creating art is still a new concept to me, but I find it to be interesting, and I’m intrigued to see just how much you can do with randomness and loops combined. I would like to incorporate random color and random movement into my work because 1) I think it would be really cool to see what unexpected and/or expected results come from it and 2) all of my projects would look related if I didn’t let randomness take over. I think the right balance between total randomness and complete control is over how serious things are. In the context of Intro to IM projects, I think the freedom to allow randomness to dominate is fine for the creative visuals, while control is more necessary for coding and the order of the code. In terms of using randomness to create everything, I question just how much it would be considered art if everything stemmed from a computer’s algorithm and you having no control over it. It reminds me of the debate over whether AI art is considered art.

Assignment 2(Loops)- Blinding Lights

Concept

My art assignment was inspired by a The Weeknd concert that I attended. I was amazed by the stage setting particularly how the lighting was done which I really liked. The criss-crossing lights that were constantly moving from all around the stage and changing colors perfectly rhymed with the vibe of the song being performed. If the song was more chaotic the lights would move faster and the color be more dark but when the song was more of chill the lights would move more slowly and be of more bright color. Adding to the video by Casey Reas on art, I came to visualize how the lights bear a chaotic theme in terms of movement and color but this chaos is what makes the concert more lively by creating a good vibe. This inspired me to try and recreate a similar thought but in terms of art. I do this by excluding the stage as a whole and just focus on the lights and the pattern of illumination and color. My art has light coming from the top and side which is moving to represent the light that is fixed to illuminate the stage alone. The circles which change size and color represent the moving lights that illuminate the audience.
Code Highlight
The part of the code that I am really proud of is how I executed the moving circles and making them change their size while moving.

// Changing size of circles
let size = 30 + sin(speed + i * 0.05 + j * 0.05) * 20;

fill((speed * 20 + i) % 255, (speed * 30 + j) % 255, 200);//random colouring
ellipse(x + sin(speed + i * 0.1) * 20, y + cos(speed + j * 0.1) * 20, size);

j += 50;

I implemented this by first ensuring that the circles have a minimum size. Then I used the sine function to generate values that change between -1 and 1. The sine wave makes the circles to move up and down and each circle having a different oscillation . Then by multiplying the sine function by the constant 20 ensures that the size of the circles also changes as they move. This whole results in the circles changing size in a wavy way. The circles also change color depending on their position on the screen which results in the circles having unique color in different places on the screen.

Visual Code

Reflection/Future improvements

I am proud of how I have been able to use loops to come up with something lively as compared to my first assignment. I am also proud of how I explored my creativity and being able to put down my experiences in terms of art using p5. For the future work I would like to have more user interaction with the art work like having mouse or keyboard engagement to directly change the art. I would also like to refine the movements of my art to be more complex and more random in order to embrace Casey’s logic of chaos. Other than that I am impressed with the art that i came up with and the progress that I have had.

Week 2 – Reading Reflection

I enjoyed Casey Reas’s talk more than I expected to, especially considering that this was the first time I had heard the idea of “randomness” and “chance” being used in an artistic context as compared to a math or probabilistic one. After I began to appreciate this notion of chance in art, I was struck by how even this is very subjective and can be used in countless ways.  One example of this is when Casey Reas talked about the concept of decision-making regarding the level of randomness incorporated into artwork. This means that artists sometimes also make conscious choices about how much of their work they leave to chance, creating “a delicate balance between order and chaos”. This also remined me of the quote by Gerhard Richter:

Above all, it’s never blind chance: it’s a chance that is always planned, but also always surprising. And I need it in order to carry on, in order to eradicate my mistakes, to destroy what I’ve worked out wrong, to introduce something different and disruptive. I’m often astonished to find how much better chance is than I am.

What I found extremely interesting about this idea was the intentionality behind randomness in art. It is about letting go of complete control but not entirely abandoning it, which can lead to unexpected, sometimes better outcomes than planned. This challenged my initial assumption that randomness in art is purely accidental and without thought. In the end, it made me contemplate: what exactly is the role of the artist? Is he still the creator of the work, or merely a medium that guides chance to reach the final piece? It also made me consider how we can use randomness not just to fill gaps but as a crucial tool for innovation and breaking away from mistakes.

One part of the talk that made it more interesting for me was the use of examples and actual works of art to illustrate this use of randomness. For instance, I found it very intriguing that something seemingly simple like the Table of Random Numbers could have such widespread use across several industries. I also liked the example of the piece “Fractal Invaders”. The idea of using a coin flip to generate art created very interesting results, but what was even more interesting was how symmetry and duplication suddenly sparks our imagination and makes us see figures in the art. It made me think that something that might initially seem highly structured or algorithmic can still engage the imagination in many ways. Overall, the talk made me rethink the creative potential of combining strict rules with the freedom of randomness, and helped me see that the “unexpected” is an important element in the artistic process.

Assignment 2: Worm

Concept

sandworm – circle – sin/cos wave

I begin with wanting to create a sandworm-looking creature from Dune. During my research, I found out this B&W worm that is visually more appealing than a big yellow worm hiding in the desert.

Few inspirations
Few inspirations

After the initial brainstorm, I started playing around with circle() & ellipse() just to experiment with the for loop. This snippet I got from one of the readings inspired me to show more of the liveness of the basic shapes.

Keeping the shape of the sandworm and the potential movement they might have in mind, I decided to create a wave. With the help of this Youtube tutorial on sin & cos wave, i was able to create a normal wave. By adding framecount into that, I create the illusion as if this sandworm is 3D. To practice using if statement, I added a colorful background that is only triggered when your mouse is moved there.


Somehow Casey Reas came in mind, so I decided to explore a bit further. For the clarity of my worm, I removed the background interaction and replaced all cos with tan. Thi si the final result:

Code & future improvement

I am happy with how the frameCount came in handy in both the fill() & circle. In future, I would give more meaning to the background.

for (i=0; i<width+100; i=i+1){
  fill(
    178+177*cos(i/2 +frameCount/2)
  );
  circle(i, height/2  + 100 * cos(i/100+frameCount/20), 50 * cos(i/30 + frameCount/50))

}

 

Week 2 Assignment: Spinning Records


Concept: 

This idea of records spinning came into my head as I was djing over the weekend and seeing how the dj software looked like:

I was also inspired by the album cover of Kanye West’s album “yeezus”:

My piece inspired by these has a couple of functions. It spins freely when nothing is touching it. Once a mouse is hovering and pressed down above one of the records, that specific records starts slowing down, eventually coming to a stop, much like a real record. Once the mouse is released, the record starts spinning again, but with a different rectangle and central circle color, as if you have swapped the record out.

Code highlight: 

// Rotate and draw elements for each circle
 let angles = [angleLeft, angleRight];
 let rectColors = [rectColorLeft, rectColorRight];
 let innerCircleColors = [innerCircleColorLeft, innerCircleColorRight];
 for (let i = 0; i < centers.length; i++) {
   push();
   translate(centers[i], 200); // Move the origin to the center of each circle
   rotate(angles[i]); // Rotate by the current angle for each circle
   drawSpinningElements(rectColors[i]); // Draw spinning arcs and rectangles
   pop();
 }

// Update angles based on rotation speeds of each record
angleLeft += rotationSpeedLeft;
angleRight += rotationSpeedRight;

This segment of code is in charge of the spinning element of the piece, using a loop, it affects both records. Within the loop, rotate is used to rotate the elements of the rectangle and the arcs. the angleLeft and angleRight incrementing is what creates the animation.

Reflection and future improvements: 

For future improvements of this piece, I would love for the record to be spinning only when music is planning, and/or have the colors respond to different parts of music like drums or snares.

Assignment 2

Concept:

For this project I really wanted to experiment with geometry and adding chaos to a shape which is commonly deemed as stable, the humble rectangle. I chose to have the rectangles rounded and translucent to further add to the playful nature of the artwork. The randomness in size, color, and movement makes each play through unique, creating a sense of spontaneity every time the code runs. The fact that they only begin to move  when the mouse is hovered is meant to mimic the human ability to see art even if any isn’t there. If a tree falls in a forest and no one is there to hear it, does it still make a sound? (If your mouse is hovering over it, then sure)

Code Highlight:

The part of this code that I’m really proud of is the way the rectangles handle hitting the edges of the screen:

if (mouseX > 0 && mouseX < width && mouseY > 0 && mouseY < height) {
    //if statement checks whether mouse is inside the canvas by analyzing       x and y positions
    //if inside the canvas, the x and y values of each rectangle is changed based on its speed and direction value which was assigned in the setup function
    rect_object.x += rect_object.speed_x * rect_object.dir_x;
    rect_object.y += rect_object.speed_y * rect_object.dir_y;

    //this checks whether the object is hitting the horizontal border by analyzing if the left or right side of the rectangle have exited the canvas, it then reverses the rectangle's direction to ensure it stay on screen 
    if (rect_object.x <= 0 || rect_object.x + rect_object.w >= width) {
      rect_object.dir_x *= -1; // Reverse horizontal direction
    }
    //this checks whether the object is hitting the vertical border by analyzing if the top or bottom side of the rectangle have exited the canvas, it then reverses the rectangle's direction to ensure it stay on screen 
    if (rect_object.y <= 0 || rect_object.y + rect_object.h >= height) {
      rect_object.dir_y *= -1; // Reverse vertical direction

It’s a small section, but it’s key to making the animation feel fluid and continuous. Each time a rectangle hits a boundary, it bounces back in the opposite direction, keeping each rectangle within the bounds of the canvas. This adds to the randomness of their movement and ensures the canvas is not slowly emptied throughout a run.

Final Product:

Reflections:

Looking ahead, I think there’s a lot of potential to make this interaction even more engaging.  I want to add a feature where clicking on a rectangle changes its size or color. Another idea would be to incorporate deceleration/acceleration effects to make the motion more organic, and make it seem as if the rectangles have weight. I’d also love to experiment with sound or other visual effects that react to the movement, turning this simple animation into something that engages multiple senses.