VEIL (Virginia's Extensible Imaging Library) is a C++ library
designed to simplify programming Datacube image processing hardware.
VEIL uses a dataflow model of computation where the nodes of a graph
represent image transformations and the arcs image paths.  Users can
either build graphs interactively using Nimue (a graphical user
interface) or call VEIL from arbitrary C++ code.

    The smallest schedulable and executable entity in VEIL is the
Graph.  Graphs consist of operators and their interconnections.
Operators are C++ classes that group the image processing elements of
the hardware, their interconnections, and their attributes into higher
level image processing primitives. For example, the elements of the
linear section of the AU device are grouped into an Add operator
class, an instance of which can add anywhere from two for four images
together.  The various attributes of the processing elements of the
Add can be specified either through Add's constructor or other public
methods.

    Once built, users can schedule and then cycle or run multiple
graphs. Graphs are scheduled as PipeOp Altering Threads (PAT's) that
group deferrable actions in the host's kernel for maximum speed.  All
processing that cannot occur inside of PAT's is performed while they
run synchronized to the relevant image processing elements.  Graphs
can also run in immediate mode.

    Other synchronization with the host cpu is handled through
callbacks and other methods.  Users can attach callbacks to a few of
the operators that will be called as often as possible synchronized to
the graph.  In these callbacks, the actual pixel or other data of the
Datacube boards can be processed.  A VEIL program that adaptively
adjusts the threshold of an image with a callback is listed at the end
of this notice.

    VEIL is easily extended to include new operators and run on new
Datacube boards.  To extend VEIL and Nimue, one has only to write
derived C++ classes.  An operator class defines its processing task by
overriding the virtual methods of the base operator classes.  A board
class defines is resources by overriding the virtual methods of the
Board class.

    VEIL runs on Sun SPARC workstations using the Performance
Technologies Sbus-to-VME adapter, as per DataCube's recommendations;
changes might be necessary to make it run with other configurations.
Currently, VEIL supports the MaxVideo20, MaxVideo200, Digicolor, and
Digimax boards.

    Nimue is a graphical user interface to VEIL.  Users can interactively
create graphs that can be later loaded and run by arbitrary C++ programs.
It is written in a combination of tcl/tk and C++.

    Currently, we use VEIL/Nimue exclusively in our day to day work.
It has proved a valuable and stable tool and has eliminated our need
to write in raw ImageFlow. 

    Here's a sample VEIL program that adaptively adjust the threshold
of the input image on a MV200:


        #include <stdio.h>
        #include "veil.h"

        int thresh = -100;
        Threshold threshold (thresh, -128, 127);

        void AdaptiveThresh (int rows, int cols, char *data)
        {
           int count = 0;

           for (int i = 0; i < rows; i++)
              for (int j = 0; j < cols; j++)
                 if (*data++ > 0)
                    count++;

           if (count < rows * cols / 2)
              threshold.SetThreshold (++thresh);
        }

        main ()
        {
           Graph graph;
           Camera camera (ab00);
           Monitor monitor (ab00);
           Import import (ab00);

           import.AttachCallback (AdaptiveThresh);

           graph.Connect (camera, threshold);
           graph.Connect (threshold, import);
           graph.Connect (threshold, monitor);
           graph.Cycle ();

           while (1)
              graph.Update (); // Calls callbacks
        }


    We hope that you will find VEIL useful, and eagerly await your
comments, suggestions and extensions.  Please direct all
correspondence to veil@cs.virginia.edu.