Week 11: In-class coding exercises

Below are the codes for each of our in class exercises including what was using in P5 and Arduino. After exercise 3’s code, you can find the video of the LED lighting up with the ball bouncing.

Exercise 1

P5 code

let distance = 0;

function setup() {
  createCanvas(640, 480);
  textSize(18);
}

function draw() {
  if (!serialActive) {
     //setting up the serial port information
    background(255);
    text("Press Space Bar to select Serial Port", 20, 30);
  } else {
    background(255);
    text("Connected", 20, 30);
    //reading the distance sent from arduino onto width of computer
    let mappedDistance = map(distance, 0, 50, 0, width); 
    //preventing ball from extending beyond the screen
    mappedDistance = constrain(mappedDistance, 0, width); 
    ellipse(mappedDistance, height / 2, 25, 25);
    //actually drawing the circle
  }
}

function keyPressed() {
  if (key == " ") {
    setUpSerial(); 
  }
}

function readSerial(data) {
  //reading the distance value given by arduino
  if (data != null) {
    distance = int(data); 
  }
}

Arduino Code

const int trigPin = 10;
const int echoPin = 9;
long timeTraveled; //variables for the distance monitor
int distance;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
}

void loop() {
  // clear whatever the trig pin. has read
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // 10 microsecond delay for each new reading
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  //read the values sent in through echo pin
  timeTraveled = pulseIn(echoPin, HIGH, 38000);
  // use this conversion to calculate in centimeters
  distance = timeTraveled * 0.034 / 2;
 /* if (distance > 500){
    distance = pulseIn(echoPin, HIGH);
  }*/
  //display in serial monitor
  Serial.println(distance);
  delay(50);
}

Exercise 2

P5 code

let brightnessValue = 0; 

function setup() {
  createCanvas(640, 480);
  textSize(18);
}

function draw() {
  background(250);
  //setting up the serial port information
  if (!serialActive) {
    text("Press Space Bar to select Serial Port", 20, 30);
  } else {
    text("Connected", 20, 30);
  //depending on where the mouse is from left to right, sending that value as a brifghtness value to arduino
    brightnessValue = int(map(mouseX, 0, width, 0, 255));
    text('Brightness: ' + str(brightnessValue), 20, 50);
    let sendToArduino = brightnessValue + "\n";
    //printing that value in serial monitor arduino
    writeSerial(sendToArduino);
  }
}

function keyPressed() {
  if (key == " ") {
    setUpSerial();
  }
}

function readSerial(data) {
  //just to avoid no readSerial error saving data
  if (data != null) {
    let receivedData = data
  }
}

Arduino code

int ledPin = 9; 
int brightness = 0; 

void setup() {
  pinMode(ledPin, OUTPUT); 
  Serial.begin(9600); 
}

void loop() {
  if (Serial.available() > 0) {
    //making sure its not trying to run unless receiving from p5
    String brightnessString = Serial.readStringUntil('\n');
    //reading the converted value from the computer
    brightness = brightnessString.toInt(); //converting to an integer
    //illuminating the led to the newly converted brightness value
    analogWrite(ledPin, brightness);
    Serial.println(brightness); //adding to serial monitor
  }
}

Exercise 3

P5 code

let velocity;
let gravity;
let position;
let acceleration;
let wind;
let drag = 0.99;
let mass = 50;
let potValue = 512;
let running = true;

function setup() {
  createCanvas(640, 360);
  noFill();
  position = createVector(width / 2, 0);
  velocity = createVector(0, 0);
  acceleration = createVector(0, 0);
  gravity = createVector(0, 0.5 * mass);
  wind = createVector(0, 0);
}

function draw() {
  background(255);
  //created this flag variable to get the ball to drop again
  if (!running) {
    textSize(24);
    fill(0);
    text("Press 's' to run again", width / 2 - 100, height / 2);
    return;
  }
  //mapping the value of the potentiometer to which direction the ball falls 
  wind.x = map(potValue, 0, 1023, -2, 2);
  applyForce(wind);
  applyForce(gravity);
  velocity.add(acceleration);
  velocity.mult(drag);
  position.add(velocity);
  acceleration.mult(0);
  ellipse(position.x, position.y, mass, mass);
  if (position.y > height - mass / 2) {
    velocity.y *= -0.9;
    position.y = height - mass / 2;
  //standard s
    if (serialActive) {
      writeSerial("Ball bounnced\n");
      //sending this to arduino each time ball hits ground
    }
  }
  if (position.x < -mass || position.x > width + mass) {
    //preventing the ball from being registered when it rolls off the screen
    running = false;
  }
}
function applyForce(force) {
  let f = p5.Vector.div(force, mass);
  acceleration.add(f);
}

function keyPressed() {
  if (key == ' ') {
    //opening setup pop up window
    setUpSerial();
  }

  if (key == 's') {
    //preparing a new ball to drop resetting the values 
    position = createVector(width / 2, 0);
    velocity = createVector(0, 0);
    acceleration = createVector(0, 0);
    running = true;
  }
}
function readSerial(data) {
  //just to avoid no readSerial error saving data
  if (data != null) {
    potValue = int(data);
  }
}

Arduino code

const int pmPin = A0;  
const int ledPin = 9;   

void setup() {
  pinMode(ledPin, OUTPUT);   
  Serial.begin(9600);       
}

void loop() {
  int potValue = analogRead(pmPin); //read potentiometer value
  Serial.println(potValue); //printing in serial monitor for p5
  if (Serial.available() > 0) { //make sure data is coming in to p5
    String event = Serial.readStringUntil('\n');
    command.trim(); //reading each newline of data
    if (event == "BOUNCE") { //sent from p5
      // turning the led on when bounce message is received
      digitalWrite(ledPin, HIGH);
      delay(100);  
      digitalWrite(ledPin, LOW);
    }
  }
  delay(50); 
}

When this code runs, the first ball is dropped from the original code and then you are prompted to open the serial connection I just cut that out of the video.

Week 10 Reading Response

In the article A Brief Rant on the Future of Interaction Design, Bret Victor critiques the current state of interactive design by highlighting our reliance on “pictures under glass” aka electronic technology using screens. He argues that they over usage of them limits the way we interact with the digital world. Victor argues that by only using our fingers to complete so many different tasks, we lack the tactile experience. An ultimately cut ourselves short of the full potential of our hands, which are intended for so much more complex and creative things. Furthermore, he envisions a future where technology engages all of our senses and thus, feels more real, bridging the gap between our physical existence and digital experience. His perspective is interesting to me because it sheds light on how we as a society are not reaching our full potential, making us creatively lazy.  I also really enjoyed his argument because it made me think of the show Black mirror, which critiques society in a similar manner and provides dystopian snapshots of what we may be on track to become.

The second article is an additional piece providing reflection on what the audience thought and Victor’s responses to that. I particularly enjoyed this section because it posed a lot of interesting opinions and arguments that I, myself thought of and agreed with while reading both articles. All in all, I think this gave an unique look at how we must balance the present of technology in interactive media and design. It is a tool with endless capabilities but we cannot let the excitement of the unknown limit us from the potential of what we still can grow. I hope to apply these principals in my design process as I find ways to combine modern and innovative technology with traditional and reliable physical experiences.

Week 10: Musical Instrument

Concept 

For this week’s assignment we spent a lot of time brainstorming ideas and developing different components of the instrument. Originally, we considered a light sensor activated lullaby machine (at night it plays a lullaby and an alarm in the morning) but weren’t sure if that actually constituted an instrument. Therefore, we decided to keep it more straightforward with an electric keyboard design that you can adjust the speed or “consistency” of the notes playing.

Materials

  • Arduino Uno
  • Jumper wires
  • 7 button switches
  • Speaker
  • SPST Switch
  • Potentiometer

Schematic

Design 

This project’s two main components are 7 buttons to play the notes and a potentiometer to control the speed of the notes playing. The green button to the left (closest to our potentiometer) represents middle C and then each button plays the consecutive note going up that scale. In our design, we also implemented a an SPST switch to control whether or not you could play anything on it, with the intention of mimicking an electric keyboard’s power button. A unique component to our design is the fact that we used both of our Arduino breadboards in order to better organize and manage the aesthetics of the design. Additionally, by still using one actual Arduino Uno we were able to avoid any complications with synching the information which was convenient in terms of time efficiency.

On the implementation side our biggest challenge was getting the volume to change with the adjustments of the potentiometer. After a bit of troubleshooting and heading back to the drawing board we decided to switch our original play and allow the potentiometer to control the speed of the notes. We intended to recycle as much code as we could from class and ultimately ended up use components from both Arduino’s tone() and button example codes that were reviewed in class. After switching between trying to change the pitch, speed, and volume of the notes with the potentiometer we decided on speed simply because we felt that the other adjustments weren’t noticeable enough for our intended purpose.

Code

#include "pitches.h"
 
// button pins
const int B_key = 4; 
const int A_key = 5;
const int G_key = 6; 
const int F_key = 7;
const int E_key = 8;
const int D_key = 9; 
const int C_key = 10; 
 
const int SWITCH_PIN = 12;  // switch pin
const int BUZZER_PIN = 2; // buzzer pin
const int POT_PIN = A0; // potentiometer pin 
 
// notes
int melody[] = {
  NOTE_B5, NOTE_A5, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_C4
};
 
// Array for button pins
int buttonPins[] = { A_key, B_key, C_key, D_key, E_key, F_key, G_key };
 
void setup() { // initalization of the buttons, buzzer, and switch pins 
  for (int i = 0; i < 7; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP); // sets button pins as inputs with internal pull-up resistors
  }
 
  pinMode(BUZZER_PIN, OUTPUT); // sets the buzzer pin as an output
  pinMode(SWITCH_PIN, INPUT_PULLUP);  // sets switch as inputs with internatinoal pull-up resistors
}
 
void loop() {
  int switchState = digitalRead(SWITCH_PIN);    // reads the state of the switch
  int potValue = analogRead(POT_PIN);   // reads the potentiometer value (0-1023)
 
  int speedDelay = map(potValue, 0, 1023, 50, 500);  // maps potentiometer value to speed delay range (50-500 ms)
 
  // if the switch is HIGH the button functionality is enabled
  if (switchState == HIGH) {
    // continously checks each button state
    for (int i = 0; i < 7; i++) {
      int buttonState = digitalRead(buttonPins[i]);
        
      // if the button is pressed,  play the corresponding note
      if (buttonState == LOW) {
        tone(BUZZER_PIN, melody[i], 200); // play note for 200ms
        delay(speedDelay); // speed delay based on the position/ value of the potentiometer 
      }
    }
  }
  delay(50);
}

Final Project 

Conclusion and Reflection

All in all, we are both rather pleased with the outcome of this weeks assignment. With it being our first assignment working with another person, it was an interesting opportunity to compare techniques in regards to simpler things like breadboard organization or schematic design preferences. We were able to use both of our strengths in different ways and support each other in areas that we were weaker. In terms of future developments we had a few smaller ideas such as adding LEDs to correspond with the keys, or allowing the user to control the pitch of the notes. Looking at the bigger picture, we even discussed what it would look like to allow the user to choose what kind of electric keyboard sounds they wanted to play (going beyond the use of the speakers we have). Although our project is rather simple, we were truly tested when it came to debugging our code but really appreciated the experience of going at it together.

Week 9: Smiley Sensors

Concept 

For this week’s project I decided to create a smiley face out of LEDs and use different sensors & switches to control different color LEDs. Conceptually, this idea is fairly simple. When I read the assignment I almost immediately knew that I wanted to do a smiley face and just had to figure out how I would incorporate the different switches in an interesting way. When I looked online I was also pleased to see that there weren’t many renditions of my idea so I felt like I had to think for myself (at least to some extent). However, I did see the use of a LED screen (not included in our Arduino kits) that I would be interested in exploring in future projects.

Final Project & Schematic 

Design

Like I mentioned before, my design is pretty simple. I am using blue and yellow alternating LED lights to illuminate a smiley face. The brightness of the blue LED’s is controlled using the potentiometer and then the yellow LEDs are illuminated using the manual switch. I enjoyed this project a lot because it really tested my knowledge of what we’ve learned in class over the last two weeks. Although it is basically what we’ve done in class just on a slightly more complicated scale, I found that introducing more components made it much more difficult to manage the information and connect pieces accordingly.

One aspect I am proud of is the simplicity of the code. In order to get this to work I only needed to implement the potentiometer code from class and have the manual switch functioning just off of power. Although this seems like common sense (since the switch connects the current itself) I had to go through a trial and error to realize the code I was trying to implement (a merge between the code for switches and the potentiometer) was virtually pointless.

Future Recommendations

In the future I would really like to improve this project by simplifying it. I originally tried to connect everything using resistors but due to other issues in my circuit ended up restarting and only using wires. Although for the sake of this assignment I didn’t really mind, the amount of wires definitely takes away for the “art” itself. I’m sure there a multiple ways I can simplify my circuit or use other materials just to minimize the “under construction” appearance it currently has. Other than that, I am fairly satisfied with the outcome and am excited to apply these techniques to more complicate future tasks.

Week 9 Reading Response Post

Physical Computing’s Greatest Hits (and misses)

Tigoe’s Physical Computing’s explores common trends on themes found in physical computing along with their pros and cons. Ranging from implementing toys as touch sensors to using our voice to complete a task, the author emphasizes the versatility we have when it comes to designing our projects. This is particularly interesting because it reminds us how endless our creativity can go as we take mundane, everyday tools and make them into something so much greater. I find this to be particularly applicable in our case because as we make the transition from software based development to hardware, a new creativity block can be formed. In other words, working with physical materials takes an entirely new level of creativity and out of the box thinking as we turn our ideas into reality. The formal introduction of these themes or common trends not only gives us an idea for how we can implement these kind of tools, but also a starting platform of ideas for us to further develop.

Making Interactive Art: Set the Stage, Then Shut Up and Listen

In this article the author starts off by establishing the common, ineffective scenario in which an artist has to walk their audience through every stage of the their creation in order for them to follow what is happening. He highlights this as one of the most important issues to be addressed because of how it heavily hinders the experience of interactive media and art. Tigoe also states that similar to traditional art, viewers deserve the chance to interpret the art on their own and strike up conversations in regards to what it means to them. I find this advice to be extremely helpful because it reminds me of the piece we read early in the semester that said interactive media should think, listen, and speak on its own. In combining these two pieces we can clearly see what makes a strong interactive piece of art and going forward I will use these standards to assess my own work for creativity, originality, and usefulness.

Creative Switch – Posture Checker

Concept

For this week’s project I had a lot of different ideas of how I wanted to create an “unusual switch.” I thought the mustache and eye-blink-polaroid designs were both really interested and tried to use the creativity and usability from either one in my design. For my project, I created a switch that notifies a user when they need to correct their posture. In my family I am known for having terrible posture and am often corrected for constantly looking at the ground while I walk. The idea of this design is to work as an independent reminder, because it tracks when you are looking down (by creating a connection in the switch), versus when you are looking up (breaking the connection.

Final Product

Design & Build Process

For this project I used the following materials: 4 jumper wires, 2 alligator cables, 1 LED light, Arduino Uno, 1 resistor, 2 cardboard circles, masking tape, and conductive fabric. For the code, I used Arduino’s pre-designed button example code. Originally, I considered using tinfoil as the conductive piece between my jumper wires but then found some conductive fabric in the IM lab so I decided to work with that instead. I found the conductive fabric a bit difficult to work with because it was so flimsy and didn’t provide a stable connection between the wires. However, I was too lazy to go buy tinfoil so before compromising on the conductive fabric I tried to work with what I assumed to be copper wire (it was actually just copper colored magnetic wire). I coiled up little pieces and clipped them on each end of the alligator clips but quickly realized that they were not conductive and resorted back to the original plan.

The circle pieces of cardboard were originally from a different idea I had of “glasses” that connect a switch when you raise your eyebrows or scrunch your nose. After I abandoned that idea I decided to use them to hook the wires onto your ears because I originally just had them hanging down.

The last thing I wanted to quickly highlight was the usage of the alligator clips to extend the jumper wires. The length of the wires caused me a lot of confusion in the design process because I wasn’t sure how I would have anything attached to my face with such short wires. My first solution was to build a small platform for my Arduino board to sit on that would raise it closer to my face but after running into a few issues with that as well a quick Google search reminded me of the convenience of alligator cables.

Reflection

Overall I am pretty satisfied with the design of my project. Although this is a very rough prototype, I have a real need for this design in my life so I was pleased to find a creative solution to the issue at hand. In terms of improvements, I would definitely like to make this design a bit more visually appealing. Although I somewhat solved the issues of the wires by using the alligator cables and ear loops, it still is quite ugly to look at and difficult to put on so that would definitely be my number one priority in improving the design.

 

Week 8 Reading Response

Emotion and Design: Attractive Things Work Better

Don Norman’s essay, Attractive Things Work Better, focuses on clarifying and further elaborating on some ideas that came into conversation from his piece, The Design of Everyday Things. He works to identify a common ground between beauty and commenting on the importance of both of them. In Everyday Things he  focuses on how designer should prioritize usability, which gave users the impression that it should be prioritized at the sacrifice of aesthetics. However, in this piece Norman explores how the aesthetics of a design can also dictate it’s usability for an individual.

For example, he proposes the idea of walking across a 1 meter wide plank at different height intervals. As the plank gets higher and higher off the ground, the likelihood that an individual would be willing to cross it decreases each time, indicating how the external factors, or appearance, can play a part in whether or not an object is usable. This is important because it further instills how the design process has to be user oriented. Not only does the design of an object itself play a role, but the user’s emotions and the greater context of how an object will be used are extremely relevant. Although finding a happy medium between the two (like discussed in the 3 teapots) is far from easy, it also creates a space for unique design as different creations can adapt to the needs of different people.

Her Code Got Humans on the Moon—And Invented
Software Itself

Robert McMillan’s article, Her Code Got Humans on the Moon, discusses Margaret Hamilton’s career while programming the code that would be used to launch the Apollo. It started out as a discussion of her career progression how she got into this field, and then focuses on her pivotal role as an engineer working on the Apollo project. Hamilton’s story is particularly interesting not only because she was a woman working in tech in the 60s, but also because the work she developed has become part of the foundation for developing software today.

As a mother, she faced lots of doubt and criticism from people who did not understand the important work she was doing. However, in her field, she was respected and welcomed for her contributions to the project. Not only did she defy the societal expectations placed on her, but she excelled in every way. Scientists such as Hamilton are strong examples of how people can go against the odds and make great strides in their field.

Midterm: 5R Photo Lab!

Final product 

Make sure to open on the P5 web editor for sound and press f for full screen please!

Concept

My main concept for my midterm was based on the photo lab that I work at in New York. I wanted to create an interactive lab experience in which the user could go through some of the steps of developing/processing film while also hopefully learning a bit more about film in the process. My main goal when designing the program was to make something that was useful to the lab and could be used by my customers.  Therefore, I ended up creating a ‘behind the curtain’ experience for customers to see what developing film is like and get small experiences in the different activities.

How it works

My program functions solely on mouse interaction and features 2 mini-games and 2.5 ‘resource tabs. The first mini-game is what I’ve considered as stage 1 of the development process, making the chemistry. Users are able to reveal the recipe card and then have to memorize the ratios for each chemical in order to make the chemistry needed for the development process. They have only 2 chances to refresh their memory but if they over pour it at all they immediately lose (because in the real world we’d have to throw the chemistry out). The second mini game is the fourth station where they are editing scans. Basically users have 15 seconds to edit 10 randomly generated pieces of ‘dust’ from the scans to prepare them to be sent off to the customer.

The two middle stations, splicing and feeding the machine do not have any major interactive piece. I made this decision for multiple reasons. The first, of course being time management and having figure out what I’d actually have time to compelte, and the second being that these stages don’t really have much that could be digitally represented like with the other two games. Step 2 typically just requires cutting a piece of film and labelling it while step 3 is literally just putting it in the machine. Therefore, by giving them this informative, resource functionality I believe it further instills how this program can be a resource for film photographers.

I also have a small easter egg which appears when you click on the film negatives hanging on the wall that just feature some photos, some of which were shot on film so that were not. While this doesn’t really add anything to the program I thought it was on theme with the design and added another layer of creativity to the project.

What I’m proud of

I am particularly proud of the mix chemicals station because it took many many hours of trial and error to reach the stage its at currently. Originally I wanted to incorporate the g, r, b, and y keys to represent filling up the vials but decided that jumping between input functions might be too much for the user. Also, while working on this station I completely deleted the relevant functions three times which I am honestly quite proud of because it took quite a bit of guts to just start over like that, but I am glad I did.

if (grow.blue && blueHeight < maxHeight) blueHeight += growthRate;
  if (grow.red && redHeight < maxHeight) redHeight += growthRate;
  if (grow.green && greenHeight < maxHeight) greenHeight += growthRate;
  if (grow.yellow && yellowHeight < maxHeight) yellowHeight += growthRate;

  // drawing rectangles
  fill('#4ba0f7');
  rect(windowWidth * 0.2 + 1.5, baseY - blueHeight, 57, blueHeight);
  fill('#f12721');
  rect(windowWidth * 0.31 - 5.5, baseY - redHeight, 57, redHeight);
  fill('#52c204');
  rect(windowWidth * 0.41 + 2, baseY - greenHeight, 57, greenHeight);
  fill('#ffeb67');
  rect(windowWidth * 0.52 - 3.75, baseY - yellowHeight, 57, yellowHeight);

The algorithm I ended up with is actually pretty simple it was just hard for me to conceptualize because I was originally unable to breakdown the mini-game into each separate requirement for what I wanted to happen. Above you can see the main part of the function that illustrates the rectangle growth.

I am also proud of the fact that everything is appropriately ratioed in full screen (or at least on my 13 inch MacBook Air screen it is) because it was a topic of growing anxiety for me as I continued to ratio everything in a split screen when I was actually implementing my ideas. Furthermore, while this is technically an area of improvement, I think that that way I problem solved was particularly effective. Due to poor design and planning I quickly became overwhelmed with the various errors I was dealing with and didn’t really know how to approach them but eventually just went back to the basic and wrote down whatever needed to be changed and I think that really helped reset  my mentality and also the direction of my program.

Please excuse my awful handwriting, it was nearing 3 AM when I wrote this…

Areas of improvement 

Although I am very happy with how my program turned out, I also have a lot of areas of improvement that I’d like to see happen in the future. During the implementation process my code was extremely disorganized and messy which cause for a lot of unnecessary confusion and frustration while I was debugging errors. Also, while the worst of it has since been improved, I did quite a bit of hardcoding that I think with the right approach could be simplified in some creative ways that I’d like to test out. Lastly, I would like to think of some more ways I can further develop the user experience. In conceptualizing this project I considered having some drag and drop features, using the the laptops camera to take a picture, and other unique components that I would like to further explore eventually.

Week 5: Midterm progress update

Concept

For my midterm project, I decided to design an interactive photo lab experience. The user starts the program off with the choice of being a customer for a day or an employee and then that decision guides their experience. As an employee, they have more of a ‘mini game’ experience (comparable to Papa’s Pizzeria on CoolMath) while if they choose to be a customer, it’s more of a learning experience for a beginner film photographer (inspired a bit by Duolingo). My main motivation for this design was based on personal experience because I started working at a photo lab roughly 2 months after I shot my first roll of film so it felt like I was learning a ton as a photographer and an employee super quickly.  I also think it would be cool if my job back home could use this as a fun resource for first-time customers.

Code progress

So far, in terms of ‘code-progress,’ I am pretty satisfied with how things are developing. Because the program is split into two sections (customer and employee experience) I devoted this weekend to just working on the employee experience. Working out small kinks has been quite time consuming because of the complexity to with which I want the program to function but I believe it is still manageable (for now). For the most part, I’ve relied on Canva for basic ‘set-design’ just to lighten the load a bit, and for aesthetic reasons so I’ve been working in layers quite a bit.

For example, this is the base layer of the processing room in the employee section. I’ve added different ‘layers’ on top so that depending on the mouse location, the program produces different signifiers that prompt you to open one of the four mini games or return back to the home page.

Most frightening part

Overall, I don’t think the implementation of my ideas will be all that difficult compelte. However, I am frightened by how tediously time consuming it will be, because it’s already taken be a significant amount of time to being making headway on 2 of the mini games. Furthermore, I still haven’t solidified what I want the customer’s side to look like, so I’m afraid that it won’t balance out appropriately with what I’ve already created.

Lastly, there are smaller things I’m holding off on debugging until the framework is fully complete and I’m really hoping that doesn’t prove to be a huge mistake. I’ve implemented the windowWidth components to try and keep my program (mostly) adaptable to any window size but quickly that it ends up distorting some of the images in a weird way and and making the space a bit awkward at times. So, I’m hoping when I circle back at the end it is a fairly easy solution.

As you can see I am relying heavily on windowWidth and windowHeight for a lot of stuff and don’t really know what to expect/how to solve the issue if it starts to not perform the way I’d like.

Nevertheless, I will try to address these concerns by working in segments, as I have been doing. With a project like this, it’d be very easy to become overwhelmed by the ideas, and implementation and everything else going on so I’m trying to keep everything broken down, into more digestible mini projects for me to complete. More specifically, in regards to the formatting concerns I think I’m gonna start recording the ratios of the important objects just have an easily accessible reference for what I’m most concerned about (i.e. making sure the instruction manual is centered). If something small is a little off, or has some slight variation from time to time, I’ll to address it but don’t want to become too fixated on little things.

Reading Response – Week 5

This week’s reading was very interesting as it dives into the technicalities of computer vision, making it seem a lot more doable, than what one might think. By breaking down computer vision into its algorithm’s basic fundamental nature, it becomes something as simple as is this pixel’s brightness greater than or less than my threshold value. Although this type of algorithmic analysis is completely different from how we as humans use vision to understand the world, it does seem like an interesting idea to conceptualize. The farthest I can reach in comparison between computer vision and human vision (as someone with no visual impairments) might be in looking at a black-and-white photo or viewing something with a stark contrast filter.

These algorithms are super interesting though because we can literally just work from light comparison in order to send different messages to the computer about what it’s seeing. In order to optimize this it is important that we give the computer clear cut distinctions from what we want it to focus on and what we don’t. I also find it interesting how beyond light, we can use things such as heat to act as the eyes of the computer.

I think computer vision’s capacity for tracking and surveillance affects its use in interactive art because opens new avenues for creativity and expression through computers. I think with the term surveillance specifically, it can also significantly reduce an individual’s right to privacy for the sake of “art.” For example, the Suicide Box project, in my opinion is completely unethical and an abuse of ‘public privacy.’ However, that then stems the issue beyond interactive art because it becomes an issue of privacy and security. Nonetheless, because computer vision has a multitude of applications I don’t believe it is at all limited to what it can be used for in interactive art, which is why we need to stay on top of its usage to ensure people’s security.