Author: Leon Ding

Talking about the conception and design, the final version of my project is close to my expectation but still far from perfection. In the Final Essay, I’ve mentioned that I was tend to use something symbolic enough to stand for human-being’s life trait and at the last, the decision was made that I’m going to use footprints, not eyes, not stickmans to denote life path. From many aspects I think footprints will work for and best suit my project: firstly, it’s natural enough to connect users’ imagination from several pairs of footprints to human, i.e. the cognition difficulty is reduced for users; besides, visualization of footprints is beautiful and remarkable for constructing atmosphere; moreover, the process of footprints’ coverage offers comprehensibility on human-beings’ relationships and paths’ crossing. As for the physical material, I finally chose two circles made of pasted cable holders, accelerometer and pressure sensory, which is wore on users’ shoes to detect the acceleration and footstep pressure thus guide the footprints’ moving on the screen. At the very beginning, I used one holder circle and one board, which hid a pressure sensory underneath, but in the user test, professor advised that I can integrate it on that circle, too so I changed that. It’s a pity that I didn’t get the chance to build it in a more futuristic way, like a plastic foot frame, which would definitely lead users to a better experience; but on the other hand, this kind of way has some flaws like a foot frame would possibly be inflexible, which rejects those who have smaller or larger feet. So finally, I let it be that way.

The most significant part in my production process would be the elements determination and coding. Due to the obscurity of my concept at the beginning, I didn’t get the chance to run a open, public and throughout user test; in order to make up for that, after I set up the plan for my project and have a embryonic form of it, I invited several friends for testing it and expected them to give my some feedback. It works well for I truly got some effective response: in my original version, the footprints controlled by the users would left a line of marks, too; one tester suggested that I should erase that because only the newest one pair of footprints would interact with others, the mark left behind would hinder users’ understanding; what’s more, the background would blink from white to black as well, and another friend told me that it made her dizzy and unable to differentiate some footprints (which are too dark or too light) from the background. So I made adaption to those elements and am pretty satisfied with the final version. Besides, the coding was indeed a challenge during the production. Though I major in CS, trying to control dozens of feet pairs’ speed, size, direction, leaving mark, color, blinking is still not a piece of cake. I edited the code for about twelve hours to get the final version.

My goal for this project, as stated many times, is to render people into rethinking and rediscover the relationships and their impact on their lives, which may remain implicit and be hard to recall in most cases. On the one hand, I’m glad I finally made a project which is pretty close to my idea and reflects some mindset kernels (like when footprints cross with each other, an audio would play to help users recall one certain experience from their memory and the controlled footprints would change its color), and this kind of interaction with users’ movements, both in visualization and audio, is exactly what I expect for a successful interactive experience; and the way users interact with the system is close to natural human walking, leading them to a scene where they are just walking on their life paths, thus this point, from my perspective, aligns with your definition of interaction; on the other hand, this project is still immature for the footprints movement is still not natural and control part is not user-friendly enough; besides, I still doubt the comprehensibility, which reflects on the fact that the project still needs explanation to make it understood. For the further development, I think a more trust-worthy hardware set is necessary; besides, I can design a GUI for the users to start the game, exit or restart; Finally, I think there’s still lots of details to improve for the visual part, which would make it more like a piece of dynamic art.

For the final conclusion, I discover that another important part of building an interactive system is that if you want to tell your users something or share a experience with them, constructing a realistic scene is necessary in order to help them break the constraints of time and space and be personally on the scene, directly leading them to one certain experience and then getting the designer’s idea. Not to mention the comprehensibility, which is of the most significance in the whole project. As for the “so what” and “why anybody care” questions, my answer is just as same as I talked in the proposal: keep introspecting and appreciating for those friends, no matter only acquaintance or best friends, whose path came across yours, and their relationships with you. This point is so important and thought-provoking that I think using an interactive project to address it would be effectively and touching. I don’t know whether my project is powerful enough to convey such a deep and meaningful idea, but that is my original idea, which I consider significant to everyone.

In this week’s lab, I use Arduino technology, basically three potentiometers to control a video’s playing speed, tint, and scale. The video is down below:

It did inspire me in the possibility of interaction between hardware and software. In this work, I use potentiometers to control parameters of the video playing and therefore, I could use more kinds of sensory to change more kinds of variables. It’s indeed thought-provoking.

The code is below:

import processing.serial.*;
Serial mp;
String s;
float x,y,dx,dy,px,py,ppx,ppy;

void setup() {
size(800,600);
background(255);
printArray(Serial.list());
mp = new Serial(this, Serial.list()[8], 9600);
mp.clear();
s = mp.readStringUntil( 10 ); 
s = null;
px = 0;
py = 600;
}

void draw() {
strokeWeight(2);
while (mp.available() > 0) {
s = mp.readStringUntil( 10 );
if (s!= null) {
String[] a = split(trim(s), ",");
dx = x;
dy = y;
x = 1023-int(a[0]);
y = 1023-int(a[1]);
x = map(x,0,1023,0,800);
y = map(y,0,1023,0,600);
line(dx,dy,x,y);
/*/if (dx-x>0) {
ppx = px-1;
if (ppx<0){ ppx = 0;}
} else if (dx-x<0) {
ppx = px+1;
if (ppx>width){ ppx = width;}
} 
if (dy-y>0) {
ppy = py-1;
if (ppy<0){ ppy = 0;}
} else if (dy-y<0) {
ppy = py+1;
if (ppy>height){ ppy = height;}
} 
line(px,py,ppx,ppy);
px = ppx;
py = ppy; */

}
}
}

And the actual project works like:

My code of using functions and arrays are down below:

int speed[] = new int[20];
int tag = 0;

void setup() {
  size(1400, 900);
  background(255);
}

void draw() {
  if (mousePressed) {
    if (tag == 0){
      background(255);
      tag = 1;
    }
    for (int i = 0; i < 5; i++) {
    strokeWeight(3);
    stroke(0);
    face(random(5,100),random(width),random(height),color(255,0,0));
    face(random(5,100),random(width),random(height),color(235,205,0));
  }
  noStroke();
  bface(50,width/2,height/2,color(0,0,255));
  }
  else { 
  background(255);
  tag = 0;
  for (int i = 0; i < 80; i++) {
    noStroke();
    float red = random(255);
    float green = random(255);
    float blue = random(255);
    face(random(20,200),random(width),random(height),color(red,green,blue));
  }
  }
}

void face(float size, float x, float y, color c) {
  fill(c);  
  ellipse(x, y, size, size);
  fill(255);
  ellipse(x-size*0.3, y-size*0.1, size*0.05, size*0.05);
  ellipse(x+size*0.3, y-size*0.1, size*0.05, size*0.05);
  arc(x, y, size*0.6, size*0.6, 0, PI);
  line(x-size*0.3, y,x+size*0.3, y);
}


void bface(float size, float x, float y, color c) {
  noStroke();
  fill(c);  
  ellipse(x, y, size, size);
  fill(255);
  ellipse(x-size*0.2, y-size*0.1, size*0.2, size*0.2);
  ellipse(x+size*0.2, y-size*0.1, size*0.2, size*0.2);
}

And it works like :

Question 1:

In your own words, please explain the difference between having your for loop from Step 2 in setup() as opposed to in draw().

The main distinctions between setup() codes and draw() codes is that setup() codes only run once while draw() codes run every millisecond (unless you use delay()  to control the frequency).

Question 2:

What is the benefit of using arrays?  How might you use arrays in a potential project?

The benefit of using arrays is, instead of controlling each variable in one sentence, you can do this once by a for loop. And it’s clearer and more good-looking defining a array rather than defining lots of variables.