Project 2 – Blow, Glow, Grow

Title: Blow, Glow, Grow

Project Description

I was inspired by assignment 3 where me and my partner experimented with combining water and light, and initially we intended to add detergent or soap water to bring more dynamics to the food coloring in the water, but later did not incorporate the idea due to time constraint. And when I was writing the proposal for this project, I thought it would be better to also create some smoke-like effects if I’m creating lights and bubbles, because with smoke it would make things more concrete and accentuate the volume of the projects instead of just hollow bubbles. In other words, besides seeing the colorful surfaces of bubbles under the reflection of light, smoke would also make them look like they are glowing themselves.

This project had two parts: first is blowing bubbles into an acrylic box with ice, and the bubbles will float in mid-air in the box because the support provided by the CO2 the dry ice releases; second part is adding water/bubble mixture into the box, and thus creates smoke and later growing small mountains of dense bubbles.

Perspective and Context

In terms of the context of art and perception, light art, and kinetic art as we’ve been discussing during the course, I find putting bubbles and smoke in a constraint space with focused light acts as a parallel of a frame to a painting, though bubbles and smoke can be observed in a natural, daily environment, having a geometrically shaped vessel can concentrate the audience’s focus on the movement of the smoke and bubbles as well as the subtle shift of colors that appears on bubbles’ surfaces. And for this specific project, having a container also allows me to create effects that would otherwise unable to achieve in a natural environment. The CO2 released by the dry ice at the bottom of the acrylic box would fill the space within and then flow out of it instead of simply disperse in air and get diluted quickly or drift away. It would then allow me to create bubbles that floats relatively steadily inside the box due to the difference of the density between air and CO2. The duration of the hovering would also be longer than bubbles normally would for the heavier CO2 holds them and keep them undisturbed. Also, I personally find them floating in a glowing cube very esthetically pleasing. 

 

Development & Technical Implementation

I first tried to laser cut an acrylic box myself because I wanted the for sides of the box to be transparent but bottom of it to be material that diffuses light well. But after spending a whole afternoon and an evening making one, I realized it is almost impossible to create a water tight acrylic box by handcrafting myself no matter haas much glue I use. I eventually bought a watertight acrylic box online and laser cut a base using milk-white acrylic to diffuse the light to create the effect of a glowing cube I was looking for. I also intentionally assembled the parts with the sides that has serration facing downward so that I could have the wires in and out easily but it also wouldn’t be very noticeable compared to having a half-hole on one of the sides.

It took me quite a while to figure out the best way to create the “smoke”. I thought about using oil-based smoke for it is much easier to control and to preserve, but then quickly gave up on the idea after looking up the tools and seeing the price of them. I later realize the fact that dry ice could also create an “invisible water” that provides buoyancy force for the bubbles, and even though I had to buy a dry ice bucket additionally to preserve it, it is still much cheaper than the oil-based smoke making tools combined, so I eventually settled on dry ice. I was very pleased to find dry ice available online and could be delivered the next morning, which made things a lot easier for me.

I did not expect the bubble water would be the trickiest and the most time consuming part. I was very confident with my formula, but when I actually experimented with it over the weekend, things did not turned out the way I expected. I referenced this video I found online for the formula, and used detergent, baking powder and guargum powder to mix with water. But when I was about to do the mixing, I realized I had no clue what the proportion of each ingredient should be, so I got into the state of repeatedly adding more water and then more of the three ingredients. But the most excruciating part was blending the powders evenly with the watered detergent, because the guargum powder would immediately turn into this clue like paste when it meets water and it was almost impossible to avoid big chunks of slippery clogs in the mixture. And because it was slippery, it was also extremely difficult to break the clogs and “release” the still dry powder wrapped inside it. I later even had to buy a boult for this. 

Though this formula can make the bubbles sticky enough and not easy to break, but when I was testing for the dry ice I realized it would also make the bubbles too heavy to float. I sometimes have to blow for minutes of bubbles before I could get one that has a perfect volume/weight ratio that allows it to float (though it might also have to do with not using enough dry ice for the testing). And it was also very skill demanding because sometimes when you blow on the straw to fast after pulling it out of the mixture it would create bubbles that have some water dangling beneath it which would also prevent it from floating. 

Another problem with this formula is that it does not create the colorful texture that you normally see in a bubble. I also found formulas that suggests adding sugar in soap water but did not adapt that despite buying a bag of well-grind soft sugar. I was glad that I didn’t otherwise it would be another hell to go through for cleaning up afterwards. 

Sadly, after all the efforts made for the bubble, I was very afraid that it would be hard to present with the very unstable bubble generation given the testings, and eventually bought a regular bubble water on Meituan to compare the effects, and hoping that by adding some of it into my homemade mixture would make things better. And the result was, it was much easier to blow bubbles when you buy the water online, AND they much prettier on line. Oh well… But, in my defense, my formula is a lot more skin-friendly and still came in handy when I needed to pour large amount of water/liquid into the box to generate smoke and grow a bubble mountain.

For the lights, I initially wanted to go for the analog LED trip and have some color changes, but after I tried plugging everything in place and test with some codes, it simply would not light up. I then went of the backup plan of using the neon tube and use a fade effect, but it was still unwilling to light up unless I connect it directly with the pawer source. I checked my wires components and the circuits I built numerous times but could not find the source of the problem. But looking back, it was probably better to go with a simple white light because a large part of the purpose is to accentuate the colors of the bubbles and the movement of the bubbles & smoke. Adding a fading effect would also make it distracting and confusing. 

( Link to code (intended to use))

Presentation

Videos of presentation:

 The presentation went OK. Though it was a bit sad I did not manage to recreate the big bubbles that covers the entire lid of the box, but I was glad that everyone seemed to have enjoyed the bubbles and the smoke and had fun trying to blow some bubbles themselves. I used a different cloth to make the big bubbles because when I was testing I could not get a cloth that is longer than 30cm with is the width of the box and I had to tie two pieces together to do it, and the knot made it very hard to cover the edge of the lid evenly to create the bubble. But the new cloth did not work very well either and I did not manage to create a big bubble during the presentation.

But then after some reflection after the presentation, I realized it is possibly because by the time I tried to make the big bubble I had already made a mess with the inner edges of the box with too many micro bubbles by pouring my homemade mixture too carelessly ( and maybe the new purchased mixed within also affected it as well), and no matter how strong the mixture the cloth soaked with is, as long as the micro bubbles break, the big bubble, which is connect with them, will too. So this is also why when I tried it again after it succeeded very quickly because by then the micro bubbles had all dried out, and when I tried to do it again with the light at the bottom in a dark room again and take a video, it was again a “mission impossible” (I later tried for half an hour in the dark), because the inner edges are messy again.

I also miscalculated the time it takes for the dry ice to convert from generating smoke to generating bubble mountains. Or it could also be that I did not add enough water and too much of my homemade bubble mixture. So the presentation also short of the “grow” part.

Pictures & videos of the bubbles I tried at home:

In these three videos you could see how water and dry ice expands a big bubble and grows a bubble mountain:

 

Here’s a video of a bubble floating for almost a minute when I was testing at home:

 

Pictures & videos of the bubbles I recreated in the classroom:

   

This video is a more satisfying smoke-swelled big bubble (the best I’ve caught on camera) and then exploding with the smoke flowing out beautifully:

In these following videos  you get to see the bubbles mountains’ growth and the colorful texture of the bubbles clearer with the bottom light and how they explode with smoke:

 

Conclusion

Some important take aways: Make sure to sand down the edges if you are working with a new, heavy acrylic box! Or at least wear a pair of gloves! Especially if there are slippery liquids involved that easily results more and ever deeper cuts form the acrylic! Also wear gloves if needing to soak your hands into detergent or bubble water, avoid soaking your hands in them for too long and wash hand immediately afterwards or else you will get alkali burned like me! (I saw these coming but did not expect them to be that bad and regret not taking enough care of myself.)

It was fun experimenting with water and mixing different ingredients for different effects. I could definitely improve on the bubbles if had had more time, and maybe try with more lights and different angles instead of just having them emitting from the bottom. From this project and the previous assignment 3 I find water has so much potential for exploration for it could take in different forms, shapes, colors and dissolve different things that brings different texture on it, an it creates fascinating effects when adding light. I think it is a nice idea to continue to explore with water and incorporate it with other things.

Assignment 3 – Sundial

For this DMX features group project we got the three spot lights. Because ours can’t really move so we tried to experiment more with the colors and the rhythm of the lights when all three on them work together.

We six struggled a bit at first with the concept, other than recreating a dial, we also thought about using selective materials or creating shadows. I proposed using a box (as shown in the picture below) that covers the three lights which would then project colorful shadows in the entire room. Or it’s also possible to have multiple wind shield like boards that has different patterns hollowed out, and would create dynamic shadows if pulling using the boards horizontally.

But after giving some thought we figured that it’s probably easier to build a wooden stick for the dial instead of making boards or boxes. But we then encountered the problem of not being able to create shadows that actually moves like a real dial. We could only make the shadows stick out on certain angles depending on where the lights were put. We tired to put the lights on the IMA chairs and moving the chairs but it would then Beto high to create a clears shadow and the lines would also be a big problem if they were to move in circles. Someone in the group also proposed combing some reflective material but apparently despite the difficulty of finding a perfect angle and installing them they would also block the view of the dial, so we gave up on that idea as well. 

Concept/present wise, we design the lights into three phases. First phase is when three of the light  illuminate one by one, second phase two at a time, the third three at a time. We wanted to use the Fade effect but then did not incorporate it due to timing. Based on this three phase design, I came up with the concept of mimicking a clock that represents the pace of our daily lives or the university life in a semester. We start off a slow paced light that changes color rhythmically, like how everything is smooth, stressless and in order. But as time go on it starts to pick up its pace and we see more colors flashing quicker, like how we accumulate more tasks. The shadows which could also be interpreted as the hands of the clock, could also mean that as we get busier we need to calculate our time more carefully and precisely, so we start from only look at the hour hand to the minute hand then to even the second hand. In the end, when the light flashes its fastest speed it could also be interpreted as the chaos derived from too much stress and work lol. One of the group members also said the colors and represent different mood, such as red for passion, green for energy and blue for being chill.

Here are the videos of the project:

 

Here is the code:

// 9 variables for the DMX channels of light 1
byte light1Dimmer = 0;
byte light1Red = 0;
byte light1Green = 0;
byte light1Blue = 0;
byte light1ColorMacros = 0;
byte light1Strobe = 0;
byte light1AutoPrograms = 0;
byte light1ProgSpeedSoundSens = 0;
byte light1DimmerSpeedMode = 0;

// 9 variables for the DMX channels of light 2
byte light2Dimmer = 0;
byte light2Red = 0;
byte light2Green = 0;
byte light2Blue = 0;
byte light2ColorMacros = 0;
byte light2Strobe = 0;
byte light2AutoPrograms = 0;
byte light2ProgSpeedSoundSens = 0;
byte light2DimmerSpeedMode = 0;

// 9 variables for the DMX channels of light 3
byte light3Dimmer = 0;
byte light3Red = 0;
byte light3Green = 0;
byte light3Blue = 0;
byte light3ColorMacros = 0;
byte light3Strobe = 0;
byte light3AutoPrograms = 0;
byte light3ProgSpeedSoundSens = 0;
byte light3DimmerSpeedMode = 0;

bool stage3shown = false;



// include the DMX library
#include 

// set the maximum amount of channels we'll need
// each light will run 9 DMX channels so 27 is enough
#define DMX_MASTER_CHANNELS 27

// pin number to change read or write mode on the shield
#define RXEN_PIN 2

// configure a DMX master controller, the master controller
// will use the RXEN_PIN to control its write operation on the bus
DMX_Master dmx_master(DMX_MASTER_CHANNELS, RXEN_PIN);



void setup() {

  // Enable DMX master interface and start transmitting
  dmx_master.enable();

  // To be extra safe,
  // let's set channel 1 - 30 to off (0) to start with
  dmx_master.setChannelRange(1, 30, 0);
}

void loop() {

  if (!stage3shown) {
    delay(2000);
    stage1Red();
    writeDMXdata();
    delay(5000);

    stage1Green();
    writeDMXdata();
    delay(2500);

    stage1Blue();
    writeDMXdata();
    delay(2500);

    stage1Yellow();
    writeDMXdata();
    delay(2500);

    stage1Purple();
    writeDMXdata();
    delay(2500);


    stage1GreenBlue();
    writeDMXdata();
    delay(2500);


    light1Red = 255;
    light1Green = 153;
    light1Blue = 18;

    light2Red = 173;
    light2Green = 255;
    light2Blue = 47;

    light1Dimmer = 255;
    light2Dimmer = 255;
    light3Dimmer = 0;
    writeDMXdata();
    delay(5000);

    light2Red = 216;
    light2Green = 191;
    light2Blue = 216;

    light3Red = 176;
    light3Green = 224;
    light3Blue = 230;

    light1Dimmer = 0;
    light2Dimmer = 255;
    light3Dimmer = 255;
    writeDMXdata();
    delay(5000);

    light3Red = 255;
    light3Green = 182;
    light3Blue = 193;
    light1Red = 0;
    light1Green = 245;
    light1Blue = 255;
    light3Dimmer = 255;
    light1Dimmer = 255;

    light1Dimmer = 255;
    light2Dimmer = 0;
    light3Dimmer = 255;
    writeDMXdata();
    delay(5000);
    stage3shown = true;
  } else {
    stage3();
  }
}

void stage3() {

  light1Red = random(0, 255);
  light1Green = random(0, 255);
  light1Blue = random(0, 255);

  light2Red = random(0, 255);
  light2Green = random(0, 255);
  light2Blue = random(0, 255);

  light3Red = random(0, 255);
  light3Green = random(0, 255);
  light3Blue = random(0, 255);

  light1Dimmer = 255;
  light2Dimmer = 255;
  light3Dimmer = 255;

  writeDMXdata();
  delay(400);
}



//2nd period: 2 lights are turned on together

 
  delay(500);

//3rd period: 3 lights are turned on together, random color, speed++

  light1Red = random(0,255);
  light1Green = random(0,255);
  light1Blue = random(0,255);

  light2Red = random(0,255);
  light2Green = random(0,255);
  light2Blue = random(0,255);

  light3Red = random(0,255);
  light3Green = random(0,255);
  light3Blue = random(0,255);
  
  light1Dimmer += 2;
  light2Dimmer += 2;
  light3Dimmer += 2;


  light1Red = random(0,255);
  light1Green = random(0,255);
  light1Blue = random(0,255);

  light2Red = random(0,255);
  light2Green = random(0,255);
  light2Blue = random(0,255);

  light3Red = random(0,255);
  light3Green = random(0,255);
  light3Blue = random(0,255);
  
  light1Dimmer += 3;
  light2Dimmer += 3;
  light3Dimmer += 3;


  // write the DMX data to the lights
  // see the function declaration below
  writeDMXdata();

  delay(50);
  */
//}


void stage1Red() {
  light1Red = 255;
  light1Green = 0;
  light1Blue = 0;
  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;
  light1Dimmer = 255;
}

void stage1Green() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;
  light2Red = 0;
  light2Green = 255;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;
  light2Dimmer = 255;
}

void stage1Blue() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;

  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 255;

  light3Dimmer = 255;
}

void stage1Yellow() {
  light1Red = 255;
  light1Green = 255;
  light1Blue = 0;

  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;

  light1Dimmer = 255;
}

void stage1Purple() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;

  light2Red = 255;
  light2Green = 0;
  light2Blue = 255;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;

  light2Dimmer = 255;
}


void stage1GreenBlue() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;

  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 255;
  light3Blue = 255;

  light3Dimmer = 255;
}


void writeDMXdata() {
  // write to channel 1-9 for light1
  dmx_master.setChannelValue(1, light1Dimmer);  // 亮度
  dmx_master.setChannelValue(2, light1Red);
  dmx_master.setChannelValue(3, light1Green);
  dmx_master.setChannelValue(4, light1Blue);
  dmx_master.setChannelValue(5, light1ColorMacros);  // 光宏
  dmx_master.setChannelValue(6, light1Strobe);       //频闪
  dmx_master.setChannelValue(7, light1AutoPrograms);
  dmx_master.setChannelValue(8, light1ProgSpeedSoundSens);
  dmx_master.setChannelValue(9, light1DimmerSpeedMode);

  // write to channel 11-19 for light2
  dmx_master.setChannelValue(11, light2Dimmer);
  dmx_master.setChannelValue(12, light2Red);
  dmx_master.setChannelValue(13, light2Green);
  dmx_master.setChannelValue(14, light2Blue);
  dmx_master.setChannelValue(15, light2ColorMacros);
  dmx_master.setChannelValue(16, light2Strobe);
  dmx_master.setChannelValue(17, light2AutoPrograms);
  dmx_master.setChannelValue(18, light2ProgSpeedSoundSens);
  dmx_master.setChannelValue(19, light2DimmerSpeedMode);

  // write to channel 21-29 for light3
  dmx_master.setChannelValue(21, light3Dimmer);
  dmx_master.setChannelValue(22, light3Red);
  dmx_master.setChannelValue(23, light3Green);
  dmx_master.setChannelValue(24, light3Blue);
  dmx_master.setChannelValue(25, light3ColorMacros);
  dmx_master.setChannelValue(26, light3Strobe);
  dmx_master.setChannelValue(27, light3AutoPrograms);
  dmx_master.setChannelValue(28, light3ProgSpeedSoundSens);
  dmx_master.setChannelValue(29, light3DimmerSpeedMode);
} 

NOC – W06 Spring Waves

 

For this project I wanted to use spring to create the waves by having many points in one line and mimic the motion of waves on a sea/water surface. I was also inspired by the ocean in the Disney movie Moana and referenced this code which helped me realize the project.

To make the surface of the water smooth, the number of spring points are set as one third of the canvas, and for the waves it’s done using two arrays with an initial length equal to the length of the spring points. Then there’s a function calculating the difference in height (diff) between the current spring and its adjacent spring(s), then multiply this with a factor smaller then 1 (which I set to 0.99 because the effect is most satisfying to me) to determine the amount of wave propagation.

In the final version of the project the code of drawing the springs is commented out but here’s a screenshot of the points being drawn.

Finally I adjusted the color to a green-blue gradient that matches the one in the movie. I wanted to draw some clouds in the background and maybe play with the transparency of the water but ran out of time. I also thought about making two sets of surfaces to create a sense of depth to the image, which is something that could be explored later on.

Here’s a video of the waves with the points drawn and a smoother animation.

 

Assignment 2 – Ripples of Light

I got the inspiration for this project from a 1.5L water bottle in my dorm. I first experimented with my cellphone flashlight, and because the water in a cylindrical clear bottle acts like a convex lens that concentrates light, and because there’s also some index that makes the surface a bit uneven, the projection of light on the wall would have a ripple-like shape and shifts and swirls when I turn the bottle. 

 

So I first had the idea to put the light source in the bottle by putting a smaller bottle inside the 1.5L one, but me and my partner later gave up on this idea because (a it looks a bit too poorly crafted if we only have some cut plastic bottles and (b I realized that it might be different if the light source is inside the water battle because it would then be the equivalent of a index lens that diffuses light and would not achieve the same visual effect as I had with a flashlight outside of the bottle. But still we gave it a try and here’s a video of what it looks like.

 

So I then proposed the idea of creating the projection through a thin layer of water, and to add variation, motion, and interaction to it, I purchased some food coloring and prepared straws to create different colors of projection and ripples. 

My partner helped draw the laser cut template and we glue-guned the pieces together. We built a lidless box to put the lights and a tray with a bottom the same size as the box to fill water in with clear acrylic. The tray will then be put on top of the box to create the shadows.

Because we shift our project to creating water ripples with a box quite late during the process, so we did not incorporate the halogen light bulb until the last minute. We first planned to just use the analog LED strip for light but realized later when testing that the light is too faint to create visible projections of ripples on the ceiling. But luckily we managed to get everything in place before presenting and the finishing result looks satisfying enough for us lol.

Here’s a video of the final version of our project.

 

If we had more time we should add a white canvas above our project because we overlooked the fact that the ceiling in our classroom is not an ideal surface to project anything on, and with an even white cloth maybe the colors form the food coloring would also be a lot more obvious.

The code is only to let the LED strip light up in blue, and I modified it last minute based on the example codes in class. For the halogen light bulb we just directly connected it to the 12v power supply via breadboard.

#define REDPIN 4
#define GREENPIN 6
#define BLUEPIN 7
 
#define FADESPEED 5     
 
void setup() {
  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(BLUEPIN, OUTPUT);
}
 
 
void loop() {
  int r, g, b;
 
  // fade from blue to violet
  for (r = 0; r < 256; r++) { analogWrite(REDPIN, r); delay(FADESPEED); } // fade from violet to red for (b = 255; b > 0; b--) { 
    analogWrite(BLUEPIN, b);
    delay(FADESPEED);
  } 
  // fade from red to yellow
  for (g = 0; g < 256; g++) { analogWrite(GREENPIN, g); delay(FADESPEED); } // fade from yellow to green for (b = 255; r > 0; r--) { 
    analogWrite(BLUEPIN, r);
    delay(FADESPEED);
  } 
  // fade from green to teal
  for (b = 0; b < 256; b++) { analogWrite(BLUEPIN, b); delay(FADESPEED); } // fade from teal to blue for (g = 255; g > 0; g--) { 
    analogWrite(GREENPIN, g);
  } 
} 

NOC – W05 Cortex Wrinkles

For this project I was inspired by this generative art piece and used it as a reference. 

The lines are created using ellipse and they are rotated around random x, y positions within the frame by applying noise in the rotate angle. I tried out different values of the angle to get different effects and the value I used in the final version is the one I think that is closest to the idea of waves. The size of the ellipse will also be controlled by the nose, but I later find that round circles looks better than actual ellipses so I made their width and height the same value.

Here are some more variation of the code in the process of experiment, basically the lager the angle the more dispersed the lines will be.

    

Here’s a video of the running code:

 

Assignment 1 Documentation

I got the inspiration for this project in the Spring Festival break on the flight back from my hometown. It was around five o’clock and I was able to see the entire sunset in the sky from beginning to end. My partner was keen on using music at first to represent the “beginning and middle and end” but after I’ve introduced this idea of mimicking a sunrise or a sunset we were quickly on board with the theme.

We had many versions of ideation on how to present the process. I first suggested making a half transparent cube where we would put the lights inside and maybe have some paper cuttings stick to the upward side of the cube to indicate the context of it recreating a natural phenomenon. My partner later came up with a better idea of making a 3-dimensional landscape that beings more depth to the visual effect, which we eventually adapted for our project.

Before laser cutting we had a long discussion on what material we should be using. We thought about transparent or dark acrylic, but in the end settled in simply plywood because I believe using transparent material for the entire body of the project would just “get light all over the place and not be able to keep them in the frame where we want to focus”.

On the day of our appointment in the fab lab I had to build the box (picture below) alone because my partner had another project she to rush and get done. She made a beautiful graph for the hills but sadly the length of the rectangle pieces don’t fit together very well, so when I was sticking the outer square frame I stuck them together in a way that the crack is at the bottom was at the bottom so it wasn’t very obvious (and it even looks a bit like a river at the foot of the hills). And I added the white acrylic last minute to defuse the matrix’s light, and it worked very well.

For the code we referenced this code. We first tried many example codes including “fire” and “pacific”, but they weren’t suitable enough to be edited to achieve the effects we wanted. For instance, I managed to get the “pacific” code into a gradient pink but couldn’t make it shift between red and orange. We then turned to our browser and found this very smooth red – orange – light blue gradient. Based on the reference code, we made the time span shorter, cutting it down from 30 min to 2 min. There was also one problem we spend a ton of time of was the timing of color shifting. Though the transition is very smooth, about more than 50% of the time it stays in Red. We experimented with numerous way of either changing the function or the numbers in the functions, but it’s either the same or finish the transition form red to blue in less than 2 seconds. I tried to make the number as specific as possible, so that it falls in the perfect spot, and I eventually discovered I had to use two decimal digits to make the timing suitable. This was the most time consuming and challenging part because it also takes a long time for every try and we had to look at the lights directly for a long time.

If we had more time on the project, we would make the box longer do the lights could be hidden inside the project instead of just hanging on the computer behind the box. But overall really like the shadows and the subtle reflections the hills created, and we realized our idea in a relatively satisfied way. 

Here’s the code we used:

#include "FastLED.h"

#define NUM_LEDS 64

#define DATA_PIN 3
#define CLOCK_PIN 13

CRGB leds[NUM_LEDS];

void setup() {
  // Uncomment/edit one of the following lines for your leds arrangement.
  //FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
  //FastLED.addLeds<APA104, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<UCS1903B, DATA_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<GW6205, DATA_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<GW6205_400, DATA_PIN, RGB>(leds, NUM_LEDS);

  FastLED.addLeds<WS2801, RGB>(leds, NUM_LEDS);
  FastLED.addLeds<SM16716, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<LPD8806, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<P9813, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<APA102, RGB>(leds, NUM_LEDS);
  FastLED.addLeds<DOTSTAR, RGB>(leds, NUM_LEDS);

  // FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
}

void loop() {
  sunrise();

  FastLED.show();
}

void sunrise() {

  static const uint8_t sunriseLength = 30;

  static const float interval = ((sunriseLength * 6.0) / 270) * 1000;

  static uint8_t heatIndex = 0;

  CRGB color = ColorFromPalette(HeatColors_p, heatIndex);

  fill_solid(leds, NUM_LEDS, color);

  EVERY_N_MILLISECONDS(interval) {
    if (heatIndex < 255) {
      heatIndex++;
    }
  }
} 

NOC W04 – Summer Pool

 

For this project I referenced this video I found online. I find making this project a very interesting one because besides applying what I’ve learned from the past week I also learned using pixel index and mathematical functions to create colors that resembles bubbly liquid.

I first started out creating the dots on a blue background that are in the middle of the “ripples”, using loadPixels () with a for loop. Then for colors, I used a graph generator to create suitable functions that would intersect the dot, which it’s position is when all the RGB is 225 white, and the values of the RGB’s respective functions’ intersection on the y axis combined is a blue. I had to also adjust the function modal that I choose and also the function and the velocity of the slop(?) of of the function, e.g. to make it steeper so that she shape or the lines of the reflection of the “ripples” would be clearer and more obvious. It is quite compicated for my level but I mostly followed along the video lol.

The biggest obstacle I encountered was to make a change to the velocity or the speed of the “ripple”. I tried many ways, but all failed (haha). I first tried to use a “shortcut” by using decay, but while the code is running fine, there’s no sign of the ripples slowing down at all no matter I value I use. 

I then tried to use multiplier, but what I get is a black canvas.

I later tried using it on the vector, but then I get this weird image of the blue haze clustered together on the left upper corner and spread out through the canvas quickly and then running on repeat. I tried to fix it but only succeeded in changing the speed of the spread.

I then tried to make it interactive, make the x axis and y axis wave move asynchronously by changing the intensity of the two waves, and also making it more interactive by adding the mouse and the key to control it, but I kept getting “not declared” when everything seems to be in order. 

So I finally gave up. While I was writing this I had an idea of adding a layer of bouncing hoops in random colors to mimic the swimming hoops in a pool, but my time was running out so did not incorporate this. If I had more time I would definitely give it a try. Disclaimer: the first three screenshots above is from the video because I forgot to take screenshot while the early stages of coding…

Here’s the link of the code.

Here is another color of the pool!

NOC W03 – Kong Ming Lantern

This project is inspired by the recent Spring Festival Vacation, and Kong Ming Lantern is something I always relate to as festive and celebratory. I referenced the codingtrain example code of balloons when writing the code.

I first had the circles into random size and I made the RGB’s red random to create a blinking effect to mimic the glow of natural flame inside a real lantern. 

I then increased the amount of “lanterns” on the canvas, changed the background into a dark grey to mimic the night sky, and used both vectors and force to make the lantern hover and when mouse is pressed they will hover quicker and wobble a bit more, as if there is a stronger current underneath to lift them higher faster.

But at this point, they look more like bubbles than lanterns, so I used vertex to draw a trapezoid.

Too small, and I made them bigger. 

But they still look odd. The beauty of setting lanterns is that it is always done with a group of people in a very open space, and the difference in distance makes them visually vary in size. But with the shape turned into trapezoid, the random radius no longer works and all the lanterns look the same.

I tried to reincorporate the circles to keep it visually interesting but they just look too messy and weird together.

 

I then made the random radius a constant and then drew the trapezoids by multiplying the radius. This worked to get the varying sizes. And I then added a “glowing candle” in each of the lamp using the similar method to recreate the flame inside. And I also added a flickering effect to the yellow flame to match the lamp’s glitching color.

I later adjusted the shape of the lantern and the velocity of the vectors again to make them look more visually pleasing. Though the shift in movement of the lanterns in the finished work doesn’t look super obvious, and this is also a problem I struggled on, but I settled on the final version because if the movement is too fast when the mouse is pressed then it won’t resemble a Kong Ming Lantern anymore.

Here’s a video of the running code:

 

Here is the p5 website to the code.

Reading Reflection 1: Light and Space

From the first reading we see the difficulty to the development of light art and why. And in the second reading, while it uses most of it’s space describing specific pieces of art work, there’s a sensible development from the first reading, and what I’ve found most noticeable was the development in technology, that as time passes, artist get to obtain more tools and materials to experiment and play with, bringing more diversity and going on further explorations. I think this in some way helped to gain attention for light art, because along with more explorations, it revealed its potential, and light just starts to feel more exciting.

In Light as Sculpture Medium, it mentioned Robert Whitman who passed away early this year. I looked up some of his works, and I noticed that he often uses projection. Despite a lot of them are not light centered, I find the utilization of projections adds a layer of diversity and flexibility in his work. For example in a performance he created called “American Moon”, projection was incorporated as a part of it. In this way, the narration takes more than the form of seeing actual objects and performers moving around but also moving images in light, which provides audience with different sensational experience, and it breaks the spacial constrains of performance, that with a piece of cloth or any surface, it could generate even more narration that other wise would be hard to present.

Performance "American Moon"

 

Another artist that was mentioned in the reading Phenomenal was Lucio Fontana. I didn’t remember who he was but was reminded immediately by the iconic cuts on papers when looking up. Though seemingly has nothing to do with light and space with the material in these well-known art works consist of only paper, the shape and shadow it creates is made possible by light and a distortion in space, that is, a slit of concave in an originally smooth surface. 

Light allow us to perceive space, and space provide light with transformative shape. Light as a rather flexible “material”, I think can help art to explore more forms of presentation and ways of expression, and sometimes help create art works that teases the human sense and create intriguing distortions of the perception. 

Project 1 – Draw the Line

I had the idea of the project when I was taking a walk around the campus. I first thought it would be interesting to walk 顺拐-ly ( a Chinese expression for walking with arms swinging in the same direction as the same-side leg), and then I thought it might be interesting to have people walking under the command of another only that the instruction for direction are the opposite of the intended direction. But then I figured the space inside and near the classroom might be too limited for doing so, thus I turned it into drawing on a piece of paper. 

When designing the shape to draw, I first come up with this bunny. But when considering practicability of drawing such a precise and relatively complex shape, having diagonal lines (and with this bunny probably too many diagonal lines), the interactions would sound too cumbersome as it needs to include both the vertical and diagonal direction and lengths.

So I then tried to design a shape consists only lines going up, down, left, or right. The first shape I drew was a heart, but when testing what it would be like to draw it through verbal instructions, I realized the convex part of a shape will always be drawing in either left or right all the time which would a lot less fun when doing it. And also because it is a symmetrical shape, to would be way predictable. I then drew this cloud shape, which looks a bit better, but despite that it is asymmetrical, the concave ins’t big enough and there’s would still be the always-the-same-direction problem.

In the end, I drew this cat-like shape because the pointy ears would help to create enough concave so that there will be enough variations to the instruction and the shape is also somewhat good-looking. 

But still, the shape seemed a bit too easy to draw, so added a 60 second time restrain to make it more challenging . But telling from actual the presentation, I probably should’ve made harder, whether in the complexity of shape or the length of time, since the participants accomplished drawing the shape quite effortlessly. Though my estimation of setting a 60 second bar was quite accurate because it took them about 65 seconds, but because I timed it in a way that I was the only one who could see the clock, looking back, it would’ve been much better if everyone could see the time, especially the person who is drawing. I should also so enough user testing before presenting to improve my projects next time.

Here’s the finished piece of the presentation:

Here’s a video of the presentation: