Why do we need new programming language primitives?

Programming language support for low-level vision algorithms has scarcely changed in 20 years. Existing programming languages provide us with arrays. Arrays are a poor semantic match to images and to the contour data extracted from images. For example

• an image is a continuous function, whereas an array represents values at a discrete grid of locations,
• image values are low-precision (e.g. 1-byte) fixed-point reals, but the standard array types include only medium precision floating-point reals (e.g. 4-byte) and low-precision integers,
• images can include locations where no value is available, but arrays can't,
• many 1D region outlines are circular, some types of image values are circular, and some images are tubular,
• mapping operators typically handle only 1D, but image arrays are 2D, and
• mapping operators enumerate values in isolation, whereas image operations process a value together with values near it.

Thus, computer vision algorithms must include considerable amounts of housekeeping to translate between user-level image semantics and array semantics. This housekeeping makes the implemented algorithms very complicated. Constructing portable, general code requires an amount of effort that few researchers are willing to invest.

Depending on the language, these difficulties may be exacerbated by inefficient implementation of arrays. Image arrays are very large (250K bytes is typical). Operations for storage allocation, terminal display, file storage, garbage collection, printing, and graphical display are often poorly prepared to cope with objects this size. Making code run at an acceptable speed often requires programming in C, or programming a high-level language (e.g. Lisp) as if it were C.

Ownership, Maintenance and Disclaimers

Manual Top Page

Last modified