Knowledge-Based Internet Search Planning (TAKEN)

Support GTRI and a government customer to use case-based reasoning to guide internet searches

.Gas Turbine Diagnostics (TAKEN)

Support GTRI and GE Power Systems to use case-based reasoning to assist in performing gas turbine diagnostics over very large data sets.

Augmenting PDAs with Displays in the Environment

A major drawback to personal digital assistants (PDAs) is their small screen size. While a PDA's computational power, memory, and battery
life will all improve with time, the size of its screen is limited by what people are willing to carry with them. If we wish to avoid having the small screen size
dictate the types of tasks we can use a PDA for, we need to find a way to improve the available screen real estate.
One way to add more screen real estate is to recognize that there are many places in the world around us where there are displays in the
environment. For example, offices often contain desktop displays and classrooms often contain projectors. If we could temporarily annex a
display in the environment when using our PDA, we could use our PDA for a wider range of tasks (or complete existing tasks more efficiently).
In addition to creating an infrastructure for annexing displays, we need to determine how to effectively use that additional screen real
estate, for example by dividing application functionality across the different displays.  The goal of this project is to prototype and study
several applications that divide input and output to the application across (at least) a PDA screen and a desktop display.

• Graphical Literature Search

The first step to implementing a research idea is to check the literature what has already been done on the subject, and how your idea differs or improves on the existing body of work. Often this involves backtracking references in papers you like, and identifying particularly salient papers.  Some of this has already been automated by search-engines like citeseer (http://citeseer.nj.nec.com/cs), but it is sometimes hard to separate junk from real relevant papers. I once toyed with the idea to put a graphical
interface to this process (http://www-2.cs.cmu.edu/~dellaert/bib/Bib2.html) but never developed into a usable application, even though this would be quite valuable. The project I propose would

• discover what a scientist/researcher would want from an interface (e.g. interactive creating of a graph, filtering, highlighting, searching text in the documents, laying out the graph in different manners)
• implement this in an application or applet, that interfaces with e.g. citeseer or with a local bibliography file. Create an application to assist literature searches in a graphical manner, by displaying the interconnected research papers in a customizable graph.
• Shape Grammars for Architectural Design

Create a user interface to specify and apply shape grammars for architectural design, with Thanos Economou from the College of Architecture.

• Firefighter Sequence Planner (TAKEN)

As part of the Firefighter Training Virtual Environment, we need a team to build a tool that will help the trainer design training scenarios. The system to be built will start off with the representation of the house that is to burn down, and will allow the trainer to enter time points and geographic locations for operations and/or facilities such as hoses, etc. The output of the system will be fed to a fire simulator that will compute the progress of fire through the building.

• Dictionary of Programming Techniques (NA)

A web-based way of submitting and accessing suitably cited segments of programs.  Submittals include information about submitter, programming language, source, and categorization. Accesses include various indexing schemes. Representation makes use of the LOOM Knowledge Representation language and tools.  This would be a continuation of work done last semester by a 3911 team.

(http://www.isi.edu/isd/LOOM/PowerLoom/index.html).

• An Environment for Testing Profile Driven Register Allocation Algorithms Based on Graph Coloring

Register allocation is an important phase in code generation used by compilers. Many architectures mandate values to be in registers before they can be used (popularly called load/store architectures such as RISC machines). Values held in registers can be used with much lower latency than those in memory.  Register allocation problem involves determining assignment of values to registers and deciding which values should be kept how long in assigned registers. This problem is solved by coloring the interference graph which shows (in a loose  sense) whether or not the values are simultaneously used together in the program (called simultaneously live values).

In this project, we will design a graph based environment to test out register allocation algorithms. Our goal is to provide infrastructure for experimentation with different allocation algorithms. We will first build an interference graph of values - each node represents a value and an edge between two nodes shows that the values are simultaneously live. Each node has a spill cost associated with it which shows how expensive it might be to use it from memory compared to a register. We will first undertake splitting phase which will split a value into its multiple "hot" or "cold parts inserting what we call "move related" edges with costs of the moves as edge weights. We will then implement iterative versions of coalescing and simplication phases and then do the coloring. We will compare our algorithms for performance -- the amount of time it takes, the number of
nodes it colors/spills, number of moves it eliminates and how far it is from optimum one. The environment could be implemented as a standalone basis or by using the gcc's output of register transfer language (RTL).

Prerequisites: Prefer someone with a compiler background/strong interest and motivation

• Falcon View (TAKEN)

In FalconView (a mapping/gis program we develop for the DoD) we frequently have a need to create a geospatial database.  Historically we have used Microsoft Access and a separate data file that indexes the database for fast queries based on Latitude and Longitude bounds.  That is to say, a where clause something like "where ("Lat" > 30) and ("Lat" < 40) and ("Lon" < 113) and (Lon > 120)".  This gets tricky when you need to consider the international dateline and the poles and standard SQL database are inefficient at these queries.  Our current solution is not "general" and needs to be re-worked for different applications.

The database would need to support standard SQL queries and have extensions for queries for distance, and queries for containment in an arbitrary polygon.  The database needs to support reads and writes (many schemes in the literature build indexes and assume the data is static after loading)

To aid in the development we could provide copies of FalconView and the FalconView SDK (Based on Microsoft COM) which has documentation and sample code in C++ and VB.  Additionally, we currently have 2 team members taking graduate courses in the College of Computing (George Menhorn and Edward Robertson).

• TeamView: Visualizing the Behavior of Social Insects (TAKEN)

We are investigating how the behavior of individuals in social groups can be automatically recognized and learned
by observing their movement patterns.  Initially we are exploring this problem by looking at social insects
(ants and bees).  We have developed computer vision software that can track the insects, and record their
positions over time to log files.

What we need, and this would be the goal of this project, is a way for a researcher to replay, visualize and annotate
the log files.  We envision something like a media player that would animate the movements of the animals.
It would have play, pause and rewind buttons, and additional bells and whistles for visualization (e.g.
a histogram of where the animals are most often located) and notation (e.g. labeling an individual's behavior).

For more information about this research, take a look at http://borg.cc.gatech.edu/biotracking

• Computational Biology (TAKEN)

Code a complex algorithm into a robust system.  This system concerns combining DNA data.   No knowledge of biology is required, the customer will provide necessary background.

• Ectropic Design (TAKEN)

Extend and upgrade the ectropic design tool (ECode) that is used in CS2340.  Customer is open to a Java port of the tool.

• TAJ: A Java Analysis Tool (NA)

Design and build a tool for Java source code manipulation.

• Digital Signal Processing, Spectographic Analysis (TAKEN)

Assist the Oberlin College Music Department in upgrading  their spectographic analysis  capability.  They currently use a  Kay DSP 550.  Sound is captured via a microphone and displayed via a 2D graph where X axis is time, Y axis is Frequency and the intensity is shown in color variations.  Additional capabilities that are desired are configuration, multiple displays and more advanced recording capabilities.  Customer wants to get rid of the old hardware (DSP) and have a PC-based software system.

• FedEx Package Estimator (TAKEN)

Customer desires a web-based application that allows a user to input an origin, a destination and a package weight and get an estimated shipping cost.

• Distributed Software Deployment Tracking (TAKEN)

Develop a system to track project files, the sites they are rolled out to, detect overlaps and potential problems in site roll-out configurations.

• Source Code Data Miner (TAKEN)

Comments in code, and the names of functions and variables may contain clues about their possible functionality.  This application would parse a C file and associate key words in comments with their appropriate function.  It also breaks up function names  and expands them (like sys_memset into  system memory set).  Basic algorithms will be provided by customer.  Implementation language must be either Java or C++.
 

• Instructor Course Scheduling (TAKEN)

Each semester instructors must submit available course times manually to the Scheduling Coordinator.    All these times have to be blocked out manually.  Also special equipment requests have to be accounted for.  Customer desires an automated, web-enabled system to do this scheduling.  Faculty Sponsor: Leo Mark.

• Software Architecture Visualization (PARTIAL)

Contact: Bob Waters (watersr@cc.gatech.edu)

Eclipse is a general Java framework for applications.  It can be extended via plug-ins.  This project is to develop a plug-in using Eclipse and GEF (Graph Editing Framework) to input description files in ACME or xADL and display them in eclipse.