Save 1000x

I created an script that would automatically save a JPG over and over again in photoshop. I had it save 1000 times. The whole process took almost 40 minutes, and the original image is still pretty intact. We’ll see how long/how many saves it takes to completely deteriorate the image.

While digitizing all of my home videos at the beginning of the school semester, I came across a series of videos of me performing in my grandparents living room. The content of the videos is similar in format to one man variety show; 7 year old Adam telling jokes, performing commercial breaks, and dancing to various songs from popular Disney movies. In an attempt to capture the essence of those moments, I decided that I would begin to learn the content. I have started by learning the choreography that I performed to The Little Mermaid’s Under the Sea and Part of That World.

Below is a clip of me performing in sync the video performance of me as a child:

In line with my thesis concepts, I am very interested in what is lost/gained/changes through the repetition and reproduction of this specific memory. I am about to embark on a series of performances that will take place in someone else’s living room. For the first performance all I would request is that the “host”, document my performance as I dance in tandem with the video of me as a child playing in the background. I would then ask my host to refer me to another person, for them to then host the next “installment” of the Living Room Series. At that performance, instead of playing the original video of me dancing as a child, I would play the documented video of me dancing to the video. This performance process would essentially become recursive over time. After several iterations I would be dancing to a video of me dancing to a video of me dancing to a video of me dancing to a video of me dancing as a child. It goes on and on….

With each repetition the original image/content gets pushed farther and farther into the background. In addition, what changes to my performance as I do it time after time? I imagine that as the dance is practiced it becomes less authentic and more “rehearsed”.

Alas we shall see as I embark on these series of performance/experiments.

For the calm technology project I wanted to make a key holder that would alert me when I was leaving my house without my keys. Using an IR sensor to detect motion in front of it, and a peizo sensor on the top to detect weight, a small melody would play to remind you to take your keys.

Unfortunately this iteration of the project was a little unpredictable. At times it would would perfectly, and at others I would be able to get the sound to stop. That being said, I was able to capture some footage of the product working! However, all the electronics were outside of the box.

Code:

#include "pitches.h"

// analog pin for reading the IR sensor
int IRpin = 1;

const int numReadings = 10;
int readings[numReadings]; // the readings from the analog input
int index = 0; // the index of the current reading
int total = 0; // the running total
int average = 0; // the average

int melody[] = {NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};
int melody2[] = {NOTE_G3, NOTE_B3, NOTE_C4, NOTE_C4, NOTE_G3, NOTE_A3, NOTE_G3,0};

int noteDurations[] = {
4, 8, 8, 4,4,4,4,4 };

// for pressure sensor
int fsrAnalogPin = 0; // FSR is connected to analog 0
int fsrReading; // the analog reading from the FSR resistor divider

void setup() {
Serial.begin(9600); // start the serial port
// initialize all the readings to 0:
for (int thisReading = 0; thisReading < numReadings; thisReading++){ readings[thisReading] = 0; } } void loop(){ fsrReading = analogRead(fsrAnalogPin); //Serial.print("Analog reading = "); //Serial.println(fsrReading); // subtract the last reading: total= total - readings[index]; // read from the sensor: readings[index] = analogRead(IRpin); // add the reading to the total: total= total + readings[index]; // advance to the next position in the array: index = index + 1; // if we're at the end of the array... if (index >= numReadings)
// ...wrap around to the beginning:
index = 0;

// calculate the average:
average = total / numReadings;
// send it to the computer (as ASCII digits)
//Serial.print("average: ");
//Serial.println(average, DEC);

float line = (4800*0.393700787)/(average - 20); //give distance in inches
Serial.print("line: ");
Serial.print(line);
Serial.print(" Analog reading = ");
Serial.println(fsrReading);

if (line > 5 && line < 10){ Serial.println("IR YES"); if (fsrReading > 50){
Serial.println("WEIGHT YES");
playTone();
}
}
}

// int fade = map(line, 0, 30, 0, 255);
//
// for (int i=0; i< totalPins; i++){ // analogWrite(ledPin[i],fade); // } void playTone(){ // iterate over the notes of the melody: for (int thisNote = 0; thisNote < 8; thisNote++) { // to calculate the note duration, take one second // divided by the note type. //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc. int noteDuration = 1000/noteDurations[thisNote]; tone(8, melody[thisNote],noteDuration); tone(8, melody2[thisNote],noteDuration); // to distinguish the notes, set a minimum time between them. // the note's duration + 30% seems to work well: int pauseBetweenNotes = noteDuration * 1.30; delay(pauseBetweenNotes); } }