This and another future assignment comprise a new project, in which you
will work with new types of interaction or new technologies of your choosing.
We will discuss several of these in class.
The project is designed to be done in teams of two people, but you are
also welcome to work individually or in a team of three, depending on the
complexity and difficulty of your project.
So the first step is to decide on your partner or team.
Our Piazza site has a feature that can help you find a partner if you like.
For this project, you can choose the topic, the technology, and the language.
You are also welcome to use Swift or Objective C for IOS
or Java for Android or Python, but you may need to learn about them on your own.
Some possible project ideas are:
- Add a new input device or modality to your previous project
- Remake your previous project as a 3D world
- Create a system that responds to its user's eye gaze as a form of input. You can use
- Create a system that tracks the user's head and/or other objects
and uses that as its input. You can use
in a similar way, by applying printed tags to the objects you want to track.
- Create an interface that responds to its user's emotion as a form of input, using
- Create an interface that permits sketching of gestures (you can use a mouse).
There are several options for doing this, one of the most straightforward is
one dollar recognizer
- Combine head tracking (using trackingjs or else put a topcode on your forehead) with 3D to provide
a "fishtank" virtual reality experience, that changes point of view based on the user's head position.
You can use a regular desktop or laptop display,
you do not need headgear or stereo
- Use head tracking (trackingjs or topcode) with your Java project so that head movements
control panning and zooming of your map.
You will probably need to add some hysteresis or damping to prevent the
display from being jittery, also ignore bad data values from the tracker.
- Create an interface that uses speech recognition. Or combine speech with
simple pointing gestures, like the like the famous 1980
Put That There system
- Design some new GUI widgets of your own.
You can implement them for your own custom framework
or code them to be plugged in as new JComponent's.
- A spiral scroll bar
- A button that you click by circling around it, or making an X gesture through it, or some other nonstandard approach
- A "safety button" that requires two actions to trigger it -- the first one "arms" it and the other "fires" it. This requires the code to remember which state it's in. Also try to design it to be self explanatory to the user
- Or your own versions of text fields, menus, or other standard widgets.
platform, without necessarily adding new interaction modalities. Add some refinements or improvements
from your previous project. If you are working in a team, you can pick one of your projects
or combine the best from both.
You should prepare:
Submit your written descriptions of the above,
sketches or screenshots as appropriate,
and the code or other material from your feasibility test.
(If your sketch is on paper, please snap a picture and include that in your
submission as a PDF. You can also scan your paper on the copier in the CS
- Initial design, sketches, high level framework, wireframe prototype if applicable.
Technology requirements/technical risks:
What are the new technologies you're planning to use?
Some of these will be straightforward, you already know how to program in Java/Swing, that's not a risk.
But you may not have any experience with, for example, using Topcodes.
So you should make some tests to make sure you can use
that system or find out its peculiarities.
Technology feasibility test:
Your low-level program(s) to test the system or technology you want to use.
If this doesn't work out as you planned in your initial design (which is likely),
you can go back and modify your high-level project sketch as needed so that it will be feasible.
Also give a very brief presentation of your project plans in class,
for the group to discuss, critique, and provide feedback for completing the project.
Team Submission Procedure
One team member should provide the main submission for the team.
Indicate both partners' full names and CS login names clearly in the readme file,
along with a short statement saying how you divided up the work.
Then, the other team member should provide a separate placeholder submission
consisting only of a readme file.
(Having this in the system gives us a place to
enter grades in provide for both team members.)
Program Design and Practices
(The rest of this still applies from previous assignments -- to the extent that it makes sense in your chosen language or system)
Your program design should exploit the features of object-oriented
(encapsulation of code and data,
support for abstract data types,
object-oriented programming provides us a good way to handle the various data needed
in callback routines.
You should use objects to encapsulate each interactive widget with the
routines and data you need to use it.
You should provide an object for each interactive widget
or small group of widgets you create.
That object should hold anything you need to remember about the widget
from one callback to another,
all the data
pertinent only to the command for that widget
or that you need to operate this control,
(including, in most cases, a pointer to the map or other outside object
to perform the actual action the user requested),
and the widget's own listener callback routines.
If you have several widgets that share some behavior or properties,
you should organize your objects into an appropriate
You will have other data that must be accessed by several widgets, particularly
information about the state of the program or global information about the
state of the user interface.
Provide additional classes and objects for holding
this kind of information.
Remember to trigger your drawing to repaint itself explicitly
whenever one of your commands causes a change
that should be reflected on the screen.
And remember that the way to change the screen is first to change the
data stored your classes and then to trigger the repaint.
You should follow these general Java programming practices:
Make all instance variables of your classes protected or private.
If you need access outside of the class, provide it with set
Avoid most global variables or widely-accessible public variables;
pass the data you need explicitly.
Put each class in a separate .java file.
And, finally, on your Java programs, for uniformity, please
name your Java class that has your main program in it
Main, in file