Category Archives: Capstone

Capstone Projects from IACD-2015

Bryce Summers

12 May 2015

The Quest for a usable, yet interesting program

BEGINNING of STORY

For my capstone project, I wanted to make a program that was somewhat user friendly. I was originally planning to make a game about elevators, but I got distracted yet again by the seductive allure of train tracks.

I set out to invent a computer game about solving puzzles by placing tracks, building logic circuits, and routing train cars.

Train Sorting Sketch

Initial Concept Sketch

I spent some time implement the representation of the train track connection network and implementing track following logic for the train cars, but I found that I had strayed off the path of crafting a program with a better user experience. I had stuck to the Bryce path and focused only on the capabilities of the program without putting some though into how they would be revealed in a pleasant manner to the user. On the technical end, I was pretty happy that I had completely refactored my old game engine and GUI and dramatically simplified it.

Screenshot depicting intersecting track.

Bare Bones Program

But at this point Bryce either did not realize that he was deviating from his path or he was stubbornly clinging to those technical aspects that he enjoys so much. He went even further down the technical and mechanics focused whole he was digging and introduced the complicated mapping logic that was necessary for his grand vision.

Screenshot 2

Fiercely Utilitarian and utterly confusing GUI layout

At this point, nobody but Bryce could use the program, because no thought had been put into the design. The theoretically capable of very complex routing logic, but nobody in their right mind would ever enjoy the experience of finding out how.

It was clearly time for a paradigm shift. Bryce decided that to enlist some outside help to try to pull himself back to the reality of programs written to be used by the common man. The guided Bryce back in the direction of common decency.

Enlightening Mockup

Enlightening Mockup

Bryce then set out converting his program into a more workable form.

As the deadlines loomed near and conflicting other obligations threatened to obscure the chances of the full game being realized, Bryce decided to convert the game into a Toy Train Simulator that merely allows the user to route cars.

So, thus inclined, Bryce set out to trim all of the excessive buttons and functionality and he distilled the car routing down to a more intuitive form.

Final Iteration for IACD

Final Iteration for IACD

Looking towards the future beyond the end of IACD, this program still has much room for improvement from a purely design perspective.

  1. The numbering of the cars has no functional purpose anymore, so I should either remove that slider or enable some sort of purpose.
  2. The buttons should be closer to where the user clicks on the grids to place the tracks. It is very awkward for the user to continuously move their mouse to the top of the screen and back.
  3. Placing tracks should be easier, I should either implement some “snapping” functionality or come up with alternative schemes for specifying track placement. One possible scheme would be for the user to only place curves and have the straight pieces fill themselves in automatically.
  4. It is critical that a delete all button be added.
  5. There is a lack of surprises. If fun is the objective, surprises may be important.

END OF STORY

In the future, I think it might be time that I retire from Java graphics programming and move onto c++ or some other language that provides manual memory management and smoother performance.

Some things I enjoyed doing in this project:

  1. I had the opportunity to completely simplify my personal game engine and GUI
  2. I had the opportunity to complete a right of passage, where I implemented the logic for trains following custom tracks.
  3. With some help, I was able to make a pseudo user friendly program. I have seen how it is possible to make improvements in user interface design with the right perspective. I sure hope that I can discover the perspective as time goes on.

Source Code: https://github.com/Bryce-Summers/JavaCode/tree/master/game_TrainOp

Thank you for looking at my Toy Train Simulator Documentation.

Epic Jefferson

11 May 2015

Signal, a free-hand gesture-based instrument for sound manipulation and performance.


This project is an exploration in alternatives for interaction with sound editing and synthesis techniques, in this case granulation.

Gestures
Currently there are 2 gestures implemented, Selection and Triangulation.


For the Selection gesture (right hand), the distance between the thumb and index finger determines the size of the window, which in turn determines which area within the sample (the subsample) that is processed by the granulation engine.


For the Triangulation gesture (left hand), the distance between the thumb and index alter the pitch, the distance between the thumb and middle finger set the grain duration. That’s it. This is already a very sensitive and expressive setup, and the key is in the mapping. Which aspect of the gestures should control which synthesis parameters? And which function should I apply to the leap data to provide the most interesting results? I think this will prove to be the great challenge of this project.
I’m happy with where it’s headed. And since I’ll be in Pittsburgh during most of the summer, I’ll have some time to work on it before next semester starts. Oh, right, this is going to be my Thesis Project for the Tangible Interaction Design program.

Sound Engine
Currently, I’m using Max for the audio engine, but it’s likely I’ll return to Pure Data to allow for embedding the engine within the application itself, and not run anything separately. It seems that sending ALL of the leap data over OSC is too much for Pd to handle (so far, this is only an issue for osx). So, the obvious fix is to only send the necessary data, the minimum. There’s still the possibility of using a C++ lib like Maximilian. Here’s my previous post on the subject.

The Studio for Creative Inquiry interview.

Future work
The next thing to be implemented is the Gesture Recognition Toolkit (GRT) library so people can teach the system their own gestures and possibly replace mine for specific tasks, like selection. Currently, the GRT library has a conflict with OpenFrameworks 0.8.4 (which is what I’m using) about C++11, here’s the forum post. This seems to have been resolved for OF version 0.9, which will be released in a few weeks, I hope. For now, it’s recommended to use a previous version of GRT, when C++11 was not yet added.

On the interface side, I’ll be incorporating a textured surface for the right hand to regain some tangibility in the interaction and rest from muscle fatigue. This should also help with repeatability in the selection gesture.

For anyone interested, I’ll post future updates on epicjefferson.com

Get the code: github.com/epicjefferson/signal

John Choi

08 May 2015

CrabTitle
Crab Controller & Crab Simulator (Spring 2015)
Interactive Art and Computational Design, Carnegie Mellon University

A 3D-printed, posable crab input joystick for controlling tetrapod walkers, motion capture, and simulations. With 4 legs and 3 degrees of freedom per leg, the Crab Controller sends data through an Arduino Mega via the Standard Firmata protocol to another device. Here, the crab controller is being used to control an underwater virtual crab simulator in real time.

 

Instructables Documentation:  
GitHub: 
https://github.com/johnchoi313/Crab-Controller-Simulator

 

dantasse

02 May 2015

What is your neighborhood made of?

Why does it feel the way it feels? What neighborhoods will “feel” similar? A lot of this is just due to what’s in it: how much of the land is dedicated to roads, how much is green space, and how much is buildings.
We don’t interact with zoning or construction in our everyday lives. We just know that some places are more pleasant than others. We don’t really see the effects of dedicating half our space to parking lots and roads. We sort of know that New York is denser than suburban Ohio, but how dense is it?
Roads Greenery Buildings is an attempt to partially answer that question.
Give it an address, it will look up the place on Google Maps and Google Earth, and tell you the approximate amount of that place’s nearby area that’s taken up with roads, green space, and buildings. You can look up a few places to compare. Here we see that my neighborhood (the third one) has more roads and buildings than Carnegie Mellon (the first one) – which makes sense; CMU is a college campus with some big lawns. My neighborhood is also a little greener than nearby Oakland.

When is it useful?

Say you’re looking for a place to live in a new city. You like your neighborhood now, so you wouldn’t mind a place that “feels like” it. Obviously, midtown Manhattan won’t feel like Squirrel Hill, Pittsburgh, but what neighborhood would?
Here’s a comparison of some neighborhoods in San Francisco, based on some coffee shops I like. The first one is in the greenest area (24th st. in the Mission is full of trees) but greenery is in short supply all around. This is to be expected; it’s a big city. I was surprised to find Hayes Valley (#4) to have so many roads nearby, but on reflection, there are a couple of big boulevards right there. Meanwhile, the area around the north Mission (#2) and Polk (#5) look the densest in terms of buildings.
This doesn’t tell you everything, of course. The space calculations are imperfect, and there’s no description of what the green space is (a highway median is not the same as a nice park, even though they’re both green) or what the buildings are (a parking garage, a house, and an office skyscraper all get the same weight). But it’s a start. I think of this (or, you know, the platonic ideal of this) as a peer to Walkscore: by no means the only tool that helps you understand a place, but one of many. What’s good? Depends on you, I guess, but I think this tool shows how places with more buildings tend to be more approachable and interesting, while green space often just makes things farther apart.
Hat tip to Andrew Alexander Price for the blog post that inspired this work. (More details.)