CSC 400 Team Project: Kleptomania


The team project for this class is to construct machine assistants to participate with a human team in the game of kleptomania.

The game works as follows: (preliminary description). Each team (3 at the moment, red, green, blue...) has a physical territory (currently a cubical) containing separated resource and collection areas (currently tables on opposite sides of the room). At the start of the game, each resource area contains some number of "treasure" objects, not necessarily all the same. The goal of the game is for a team to accumulate as many objects as possible in their collection area, either by moving them from their own resource area, or stealing them from other teams' resource or collection areas.

The machine system has both surveillance and strategy roles. The surveillance role is to monitor its team's territory using cameras, (and possibly microphones) and sound an alarm in the case of attempted theft, while allowing its own team to move objects as needed. A team member who triggers an alarm, either by his own, or an opponent's machine, is penalized by being unable to play for the next 2 or more turns (in jail) , with an additional 3-strikes and you're out condition (in hell).

The second machine role is to control the strategy of the game by instructing its own team members on what to do (e.g. "Jon should try to steal an apple from the green team's collection area") Team members may take only actions dictated by the machine. An important issue is defining a reasonable information-collecting strategy that will support this. You need some information about what might be stealable and from who, and what succeeds or fails, and if there are queues for various territories. Trying to obtain this information from observation in addition to detecting intrusion seems too messy (too many cameras looking at too many things). Instead, we have the information entered by human "spies". The difficulty here is defining a reasonable set of rules for information entry/gathering that prevent "coding" strategies that essentially allow the players to direct the action at a fine-grained level. To address this we will define a common language that the players can use for communication back and forth with the machine.

Here's an outline of how this works. Information is supplied to the machine by the players; but it must be in the form of true, simple factual statements such as "the green team has 3 oranges in their collection area". We prohibit deliberate coding schemes (e.g. making the same statement about the green team's clocks 3 times means that Jon should try to take a clock from from the green team. The idea is that the users do not need to know anything other than the surface meaning of a statment in order to interact succesfully with the machine. Following this up, we should imagine that the source of information be a naive participant responding to initiatives by the machine. And questions of the sort "Is the next person coming into my territory an opponent?" (so the machine can ring an alarm) need to be disallowed in the language. Let's assume the queues are hidden, You know if there are other people lurking about the entrance to a territory, but you don't know who they are. Or just no communication from the executive agent to the surveillance/alarm system.

One approach to handling the communication that seems to work relatively well is for one member of each team to be the "dungeon master" who calls out to the team members what the machine has instructed them to do and enters the information requested by the machine. Of course, if anyone wants to do a distributed system with PDAs, that would be cool... All dialogue should be posted to the public display during a game.

The game continues until either all members are permanently out, or a specified time (20 turns) has passed. The winner is the team that has the most objects in its collection area when the game ends.

To make the game work, some rules similar to the following seem needed. There might be others as well.

Teams



Preliminary Territory Design

Team territory is an 8x8 foot region containing two tables. The back boundary is a wall. The sides may be walls or dividers extending out at least 6 feet. There are two Cannon pan-tilt-zoom ceiling cams mounted approximately as shown. These are connected to a dual-processor computational sensor, whose terminal is adjacent to, but outside of the territory.

Getting started

As a step towards designing the project, you should become familiar with these machine vision resources. Once you have done this, you could check out the program "discover_objects" in ~nelson/programs/src/integrated/bin. (if it doesn't run, compare your LD_LIBRARY_PATH to the one defined in my .cshrc At least the /usr/vision/lib directory is needed. I don't think that /u/igreen/lib/SunOS and /u/sanders/lib/SunOS are needed any more. If they are, let me know. I should probably change it.) This implements a version of object discover via change detection, and contains components that adaptively model background, detect and segment foreground, try to determine if an object appeared or disappeared, and even call an object recognizer. It won't entirely solve your surveillance problem for you, but it might be a good foundation. (On the other hand, it might limit your ultimate performance if you take it too seriously) And I wouldn't specifically recommend that you try to use the recognizer - you probably won't have time to get enough views to train a full 3D model (though I could see a strategy involving only a couple of views, and careful attention to placing the objects in one's own territory).

Reference Material

Some classic vision (and newer) vision papers relevant to the project are listed below. This list may see additions, so check back occasionally.

Infrastructure Assignments

Back to CSC 400 main page