Reading Response – Computer Vision

The overview on using computer vision in interactive art really sparked my imagination. Of course algorithms can analyze images – but creating immersive experiences that actually respond to someone’s real-time presence? The possibilities seem endless. Still, I wonder – at what point could systems become too reactive? Krueger’s Videoplace reacted whimsically, but always ethically. The line between delight and dystopia likely needs careful watching.

Even with today’s exponential tech growth, restraint remains critical in design. Amidst the complexity, what separates a seamless experience from one that’s cluttered and confusing is knowing when enough is enough. But making those calls is an art, not a science. The LimboTime game showed how a playful vision system could emerge from simple building blocks. Yet its limitations in changing lighting reveal the fluid and adaptable intuitions still required.

Overall this piece brought great food for thought on computer vision’s creative possibilities. The blend of concrete examples and big picture analysis kept an engaging pace. I appreciated the framing of challenges creatively rather than just technically. This hit a sweet spot between grounding me conceptually and sparking curiosity to apply these ideas further. The writing style created enjoyable momentum.

Reading Response – The Psychopathology of Everyday Things

The psychological principles for design make a lot of sense to me. Of course affordances and mental models would shape how people use stuff – those concepts seem so core. Formalizing them into the design process feels overdue in a way. Still, I wonder – following guidelines can limit you too, can’t it? The times I’ve felt the spark of creativity or problem-solving have actually come a lot from defying conventions or unspoken “rules.” So where’s the line between guidance and overstandardization? Feels like a tension worth watching.

And even with technology’s insane pace of advancement, I think designers still have to be minimalists at heart. What separates a seamless, delightful experience from a bloated, confusing one is restraint and knowing when to stop adding features just because you can. But how designers make those calls is an art, not a science.

One part that really resonated was thinking about mental models across teams. We all carry biases and assumptions and lenses we see the world through. That exists even (maybe especially?) in cross-functional groups. Creating spaces where communication norms themselves feel simplified and clarified could make a world of difference in alignment, collaboration and innovation. There’s surely design opportunities even in how organizations function on a daily basis.

Overall this piece brought up great food for thought, and refreshed my appreciation of design thinking. I like writings that make me feel both grounded conceptually and curious to apply ideas further. This hit that sweet spot through framing the challenges creatively vs. just technically. The blend of examples and analysis kept a nice engaging pace too. Overall, this was a really enjoyable read!

Assignment 4 – Fortune Cookie

I’ve always loved cracking open fortune cookies to see the surprise message inside. I decided to recreate this idea digitally by building an animated, interactive fortune cookie in p5.js that reveals a new quirky fortune each time it’s clicked.

The core concept here was to display random fortunes generated from a list of silly phrases. I started by coming up (with the help of ChatGPT) with a whole array of potential fortune texts – things like “Run” or “Don’t eat the paper.” I tried to channel the cryptic non-sequiturs you might find in real fortune cookies.I then set up a pickNewFortune() function that can select a random element from this master list of fortunes. This gets called every time the cookie finishes its opening animation.

So on each cookie click, it grabs a new random index from the list and stores this fortune string to display.

The visual animation of the cookie opening was also really fun to build out. I made the separate cookie halves tilt back and apart slowly to reveal the text underneath. I’m really happy and proud with how realistic the motion looks!

The code for the animation looks like this:

function animateCookie() {
  let halfAnimationStep = maxAnimationStep / 2;
  let angleOffset, pullOffset;
  
  if (animationStep <= halfAnimationStep) {
    // Tilt cookie halves apart  
    angleOffset = map(animationStep, 0, halfAnimationStep, 0, -40);
    pullOffset = 0; 
  } else {
    // Finish opening animation
    angleOffset = -40;  
    pullOffset = map(animationStep, halfAnimationStep, maxAnimationStep, 0, 200);
  }

  drawFortuneCookie(angleOffset, pullOffset);

  // Progress animation
  if (animationStep < maxAnimationStep) {
    animationStep++;  
  } else {
    state = 'open'; 
  }
}

In the future I could definitely expand and refine this concept even more – perhaps allowing the fortune text itself to animate in different ways for some visual variety. I would also love to enhance the text generation further – for example, mixing and matching fortune text fragments to assemble new combinations. I could also display the text animating onto the screen for more visual interest when the fortune is revealed.

Reading Response 2- The Art of Interactive Design

This reading totally shifted my thinking on what interactivity really means. The metaphor of a back-and-forth conversation was a lightbulb moment for me. Like two people listening and responding to each other. It clearly shows why a book isn’t truly interactive even when it fully engages me. A book just conveys information, oblivious to my reactions. It doesn’t necessarily tailor itself to me.

Framing interactivity as a spectrum rather than a yes/no thing landed perfectly too. It’s like turning the volume up and down – experiences can be more or less interactive. A video game responds more to me than a cooking show I passively watch. And good graphics or UI design is only part of the equation – you have to build in that two-way communication. Looks alone don’t cut it.

I’ll admit some sections felt dense on first read. But the big takeaway was that interactivity isn’t just about engagement, it’s about a back-and-forth exchange where both parties actively listen and speak. Measuring where something falls on that spectrum makes me evaluate all kinds of media differently now. How much am I conversing rather than just being “spoken to”? Food for thought as I wrap my head around design. Overall, this was a solid, informative read.

Assignment 3- Interactive Grid

For this assignment, I wanted to create a geometric and interactive artwork using OOP and functions. I was inspired by this youtube video: https://www.youtube.com/watch?v=4lCD9B4Dlik

My idea was to have a grid of spinning dial controls. Each dial displays a different hue pulled from the colour spectrum and it gives the final piece an ombre effect. As you move your mouse across the grid, the dials swivel to follow along. It creates this really cool hypnotic effect!

I created a Dial class to represent each control. In the setup(), I iterate through a 2D array to place Dial instances in rows and columns. I calculated the number of rows and columns based on the canvas size to fully fill up the space.

Each Dial is coloured according to its position in the grid using HSB colour mode. This lets me pull nice saturated tones from around the colour wheel. I mapped the grid indices to hue, saturation and brightness values. This creates a smooth gradient of colours.

for (let i = 0; i < cols; i++) {
  for (let j = 0; j < rows; j++) {
    // Map the grid position to HSB color values
    let hue = map(i + j, 0, cols + rows, 0, 360);
    let saturation = map(i, 50, cols, 100, 100);
    let brightness = map(j, 50, rows, 100, 100);

    // Set the fill color based on mapped HSB values
    fill(hue, saturation, brightness);

    // Call the rotateDial method of the  Dial instance with the current mouse position
    dials[i][j].rotateDial(mouseX, mouseY);

In draw(), all that’s left is to animate the Dials. This simply involves calling each Dial’s rotateDial() method, passing in the mouse position. Some tweaking was needed to get the rotation speed and smoothness right.

While the core concept is simple – a grid of colourful spinning things – the end result is quite striking and mesmerising. As the mouse moves, these colourful triangles swirl around the grid in different patterns. The black background makes it stand out and I’m pleased with how well it turned out.
I’m considering ways to expand on the idea in the future, maybe adding interactivity to control the colour mapping or rotation speed. I’m open to suggestions for other fun tweaks!

 

Reading Response – Week 2

Reas’ insights on randomness in art had my mind filled with ideas. When he described the paradigm shift from order to uncertainty in physics and culture, I realized I had falsely assumed randomness was somehow “less intentional” in creative work. Tracing how artists have deliberately experimented with chance way before coding was even possible blew open my assumptions even further. 

I love how Reas constantly tries to balance structure and surprise within his algorithms for that sweet spot of organized chaos. Like how adding a smidge of noise to those otherwise uniform lines in “process 18” made the composition pop with organic energy. You could vividly see homeostasis at play. I also loved seeing the psychedelic patterns generated from the 10 Print Commodore program. I had childhood flashbacks to PC screen savers!

It intrigued me to learn Reas often repurposes snippets of code from other pieces to birth totally new visuals. His “Written Images” with its ever-morphing permutations seems like a concept that has potential for everything from music videos to merch design. As someone getting more into creative coding and graphic design, I find Reas’ perspectives hugely inspiring. The intersection of algorithms and chance is such a rich territory for innovation. Rules exist to be broken!

By engineering the tango between random and restrained, predictable and unprecedented, Reas’ work made me recognize chaos as creation rather than destruction. I’m now excited to further explore similar computational art by pushing boundaries and creating creative messes. 

 

Assignment 2- A Nocturnal Landscape

Assignment 2- A Nocturnal Landscape

Concept

I wanted to create a vivid landscape scene with a night sky, mountains, trees, and an ocean using basic p5.js shapes like rectangles, ellipses, and triangles. I used basic shapes and coordinates, but tried to make the end result visually interesting and cohesive even if not realistic. I used a loop for the stars to randomise their position on the canvas. I also slowed down the frame rate to have a calming feel to the overall movement of the stars.

This is my final artwork:

I’m most proud of the for loop I created to make the gradient sky:

 // pretty sky
for(let i=0; i<=300; i+=5){
strokeWeight(5);
stroke(255-i,128-i,64);
line(0,300-i,width,300-i); // x,y,x,y
}

This loops over and over again and draws coloured lines that transition smoothly from dark blue to orange. The decreasing RGB values create the gradient illumination. I took inspiration from an existing p5js project by @urbanatwork for the gradient.

I spent the most time on the coniferous trees, positioning the triangle branches and creating the function proved trickier than expected but I am proud of how reusable and handy I made it. This is the drawConiferousTree() function:

function drawConiferousTree(x, y, a, b){
//tree trunk
fill('#691C37');
ellipse(x, y-20, a, b);
//tree branches
triangle(x-15, y-20, x+15, y-20, x, y-50);
triangle(x-15, y-30, x+15, y-30, x, y-60);
triangle(x-15, y-40, x+15, y-40, x, y-70);
}

What I like about this is it allows me to easily draw as many tree shapes as I want by just calling this function each time with the tree’s x,y coordinate, trunk width, and trunk height.

For example, to make two trees at different places, I can just do:

drawConiferousTree(15, 305, 4, 20);
drawConiferousTree(35, 310, 4, 20);

The variables a and b even let me adjust an individual tree’s proportions if needed.

I learned that making custom functions with parameters is hugely helpful when you want to repeat elements, like trees of the same style but different sizes and positions. It’s like having a custom stamp that you can use wherever you want!

Reflection

I’m thrilled with how this landscape came together. The colours, composition, and simplicity have an engaging but simplistic aesthetic that is calming to look at. I definitely plan to keep working on this piece.

Going forward, I want to add more interactivity into the scene to bring it alive. For example: Make the sun rise and set over the mountains as I move my mouse vertically across the screen. This would create daylight cycles and slowly change the sky colour. I would love to further experiment with the sky gradient as well.

This project has me hooked to p5js and its endless opportunities for creative projects in the best way. I’m excited to include more interactive and engaging elements in my projects moving forward.

 

 

 

Assignment 1: Self-portrait

Self-Portrait

The aim was to draw a simple 2D portrait using basic shapes and solid colours. Since it was my first time experimenting with p5, I kept my design fairly simple and mainly worked on familiarising myself with the basic concepts. I would love to continue improvising my self-portrait as I learn new skills.

For the portrait, I used simple geometric shapes for the head, hair, eyes, nose and mouth. I used pre-defined constants like PI and QUARTER_PI to draw arcs and ellipses. I used the p5js reference library to learn how to rotate a shape.

In reflecting on this project, I realised there are many possibilities to make the portrait more creative and personalised. For example, I could add interactivity to have different facial expressions. I could also add more detail like ears, eyebrows, and hair texture. The background could be customisable with different colours or shapes.

I look forward to learning more complex p5js functionality. In my next projects, I plan to incorporate animation to bring more life into my artwork. I now feel more comfortable with the basic syntax of p5js. With more practice, I hope to make projects that are visually engaging and fun to interact with. I’m excited to continue growing my coding and creative skills.

arc(200, 300, 50, 20, 0, PI); 
// hair
strokeWeight(1);
stroke('rgb(53,30,30)');
fill('rgb(53,30,30)'); 
angleMode(RADIANS);
rotate(0.72);
ellipse(240, 35, 50, 130);
rotate(1.5);
ellipse(10, -300, 50, 130);