# Kinematics-to-Color Conversion Game

February 13, 2012

[VIDEO TO COME]

**I. Introduction**

This project was very experimental in nature. I wanted to create an interface that uniquely translated the mind’s understanding of one common system onto a very different common system through a simple switch interface. Both the physics of kinematics and the science of color have always intrigued me. With this project I attempted to interface the two systems by means of an alternative method that the human mind would not typically think of. It was my hope that this odd translation would provide a new lens for understanding both systems, as well as, shed a new light on the human mind’s perception of a system. In the end I decided to turn the interface into a game that tracked the player’s progress of how well he or she was able to translate between the two systems of calculus-based kinematics and the RGB color system.

**II. How It Works**

This game assumes that the player or viewer has a basic understanding of the RGB color system in addition to grasp of the calculus-based relationship between position, velocity, acceleration, and jerk (the rate of change of acceleration). Through 4 clicks of the button (or switch) at the center of the application the system tracks the absolute value of the velocity, acceleration, and jerk of this interaction. It does this by assuming a “distance” of 3 units – 1 unit for each click after the first one which is supposed to represent the starting line. It then generates an average *velocity* (** v**), average

*acceleration (*, and average

**)***a**jerk*(

**) based on the timing between each of the 4 clicks. These three values are then mapped onto the R, G, and B values respectively. The algorithm behind the conversion assumes that the user’s 4-click timespan (total time) will be between 0.1 seconds and 30 seconds.**

*j**Method for Calculation *

*(Note: the values calculated for v, a, and j are rough averages due to the fact that there are only 4 data points recorded. Additionally, this is one method of averaging the data but there are numerous other ways these averages could have been calculated.)*

Referenced Variables: **T12** = time between the first and second click, **T23** = time between second and third click, **T34** = time between third and fourth click; additionally **T1** = 0 (first click starts timer), **T2 = **time of second click referencing the timer that starts with the first click, **T2.5** = the time halfway between the 2nd and 3rd click, etc.

Velocity: This is calculated as the total distance, 3, divided by total time, T14: x/t

* v* = 3 / (T12 + T23 + T34)

Acceleration: This is calculated as the of the average of the local accelerations between click 1 and click 3, and click 2 and click 4. In other words the change in velocity from T12 to T23 is averaged with the change in velocity from T23 to T34. I used this method because in order to calculate an acceleration there needs to be a flux in velocity and with the recorded data there are actually two fluxes in velocity (at click 2 and click 3). Note: t

** a** = ((A123 + A234) / 2)

**A123** = (V23 – V12) / (T2.5 – T1.5) and **A234** = (V34 – V23) / (T3.5 – T2.5)

Jerk: This is calculated as the of the rate of change of acceleration between A123 and A234

** j** = |(A432 – A321) / (T3 – T2)

*Method for Conversion*

Once the user has flipped the game’s switch 4 times each of the absolute values, or magnitudes, of the above calculations (*v, a, *and* j*) are respectively mapped onto a 0-255 range of the red (R), green (G), and blue (B) values of a color. Initially the system mapped the lowest extremes of negative ( – ) acceleration and negative jerk to values of 0 for G and B respectively. This was not necessary for velocity-to-R bc it was impossible to generate a negative value for velocity. After some testing, however, I decided to change the conversion to where it used the absolute values of velocity and acceleration to map to the 0-255 ranges of G and B. My rationale for this change was that the interaction between the two systems is confusing enough and shouldn’t include variable ranges for (a and j), with both negative and positive possibilites, that map onto the G and B variables that only have positive ranges. Therefore, as it stands now acceleration values of 0 to 10 are mapped onto G-values of 0-255. The original method had acceleration values of -10 to 10 being onto G-values of 0-255.

# III. Process

*Concept*

*Early Sketches and Calculations*

These sketches and calculations show some of my thought processes in the development of my system to generate the average values for v, a, and j. This was the first phase of my pseudocode before jumping into Openframeworks.

This is the first sketch for the layout of the game’s interface.

*Manifestation*

The final aesthetic was done in Photoshop and the back-end coding was done with Openframeworks. Below is a screenshot and sample code of the variable I used:

# IV. Conclusion

The game is not too difficult to pick up if you have a good understanding of calculus and/or kinematics, but it is very difficult to master due to the limited number of player inputs. I found it hardest to produce a deep green color. This entailed producing a high but constant acceleration without a high velocity or jerk.

Moving forward, I would like to get this game up on a website so that more people could test it. Additionally I would like to make it social by adding a high scores database that all players can view and compete for. In terms of practical applications for this type of conversion, a similar system might be beneficial to do data visualization in industries where calculating jerk is important. Examples where people consider jerk include: boxing (the higher the jerk, the more devastating the punch), car accidents, etc.