The snBench project aims to design and implement the
programming and run-time infrastructure necessary for developers to
specify and deploy truly distributed applications over a heterogeneous
network of Sensing Elements (SEs) and of Computing Elements (CEs).
snBench offers the means via which applications may (1) locate, monitor,
and query SEs and CEs for services they support, and (2) initiate,
control, or otherwise use such SE and CE services. In addition to
supporting these functionalities, the snBench provides basic run-time
resource management services for QoS support, including real-time
scheduling and admission control functionalities. While the architecture
of the system and most of its services will be targeted at generic
sensing modalities, our immediate target will be the Sensorium
infrastructure. To that end, the basic set of SE services to be made
available to distributed applications will include 'atomic' video
operations (e.g., video frame capture, blob counting, motion detection,
tracking, among others) whereas the basic set of CE services to be made
available to distributed applications will include in-network stream
aggregation services (e.g., concasting coordinates of detected features,
real-time stitching of frames from multiple vantage points, among
others). One of the salient features of snBench is extensibility. To
that end, snBench provides a type-disciplined framework for defining and
adding new services--both atomic services at SEs and compositional
services at CEs.
Emerging configurable infrastructures such as the
Sensorium comprise diverse sets of available computing and networking
resources whose characteristics are both complex and time-varying. At
the same time, applications to be deployed on these infrastructures
exhibit increasingly complex constraints and requirements on resources
they wish to utilize. Examples include selecting nodes and links to
schedule an overlay multicast file transfer across the Grid, embedding a
network experiment with specific resource constraints in a distributed
testbed such as PlanetLab, or dispatching sense-and-compute processes
over a distributed sensor network such as the Sensorium. Thus, a
common problem facing the efficient deployment of distributed
applications on these infrastructures is that of "mapping"
application-level requirements onto the network in such a manner that
the requirements of the application are realized, assuming that the
underlying characteristics of the network are known. We refer to this
problem as the network embedding problem. In this project, we pursue a
set of approaches to tackle this combinatorially-hard problem.
These approaches are fleshed out in a service (called netEmbed) which we
have shown to be quite effective in identifying one (or all) possible
embeddings for quite sizable queries and hosting networks.
It is difficult to develop correct, efficient, and
resilient networking applications, especially on infrastructures such as
the Sensorium, which are meant to host many such applications, each with
specific safety constraints spelled out as requirements on performance,
security, etc. The heterogeneity and open nature of such systems
make the certification of component composition quite challenging.
Towards that end, in this project we aim to make the design and
implementation of certifiably robust services on infrastructires such as
the Sensorium accessible to the average programmer. We accomplish this
by breaking down the specification of a an application into two parts:
specification of flows and specification of types. Specification of
flows describes the topology and composition of the networked system,
and how individual components are connected to each other. We expect
this part to be accessible by any average programmer. The specification
of types formalizes properties of a network in terms of some concrete
syntax that can be understood and analyzed automatically by our type
system. This is more difficult to specify, but the efforts of a limited
number of experts can be shared.
The Camera Mouse is a system that tracks the
movements of computer users with a video camera and translates them into
the movements of the mouse pointer on the screen. The approach is based
on correlation of brightness patterns and recursive filtering. Another
system is the Blink Link, designed for people who have extremely limited
muscle control, but are capable of blinking voluntarily. Such users can
generate selection commands through their eye blinks in order to operate
switch-based scanning programs and on-screen keyboards. We have
developed systems that use deformable templates to detect eyebrow raises
and generate selection commands control the camera's pan, tilt, and zoom
mechanisms to actively detect and track the user's head and eyes, and
interact with the computer with hand gestures. Ongoing research focuses
on methods to detect unique patterns in the voluntary movements that a
particular child can make comfortably. The interface will then be
developed to recognize these patterns and provide an efficient tool for
Fast Face and Eye Tracking
Over 100,000 severely paralized people in the United
States have only the ability to control the muscles in their eyes. For
these people, eye movements or blinks are the only way to communicate.
Previous attempts to provide an interface system are intrusive or
require special hardware. We are creating a system that can run on an
average PC with video input from an inexpensive USB camera. The goal is
to detect if the computer user is looking at the screen, or off to the
left or right side. The output of our system could be used as an
interface for the computer. The face is located and tracked in the video
images using a variety of computer vision techniques: color histograms,
motion analysis, and multi-resolution template matching with normalized
correlation. Once the face is located, analysis of the eyes can begin.
SlurpCast is a media
streaming server that is written in O'Caml, a type-checked, memory-safe
functional language. O'Caml is chosen because it offers the choice
of functional-style programming and imperative-style programming,
and partly also because O'Caml is well-supported by its community.
This project is an attempt to see how much functional programming
constructs can be used to model a network server architecture.
Combinator functions are designed and used extensively in SlurpCast to
accommodate the extensibility and flexibility needs of a modular server.
SlurpCast also adopts synchronized queue and thread communication from
imperative programming concepts.