We propose a generic computational framework for maintaining a discrete geometric structure defined by a collection of static and mobile objects. We assume that the mobile objects move incrementally, that is, in discrete time steps. We assume that the structure to be maintained is a function of the current locations of the mobile and static objects (independent of their prior motion). Unlike other models for kinetic computation, we place no restrictions on the motion nor on its predictability. In order to handle unrestricted incremental motion, our framework is based on the coordination of two computational entities. The first is the incremental motion algorithm. It is responsible for maintaining the structure and a set of certificates, or conditions, that prove the structure’s correctness. The other entity, called the motion processor, is responsible for handling all the low-level aspects of motion, including computing and/or tracking the motion of the mobile objects, answering queries about their current positions and velocities, and validating that the object motions satisfy simple motion estimates, which are generated by the incremental motion algorithm. Computational efficiency is measured in terms of the number of interactions between these two entities.

In k-means clustering we are given a set of n data points in d-dimensional space ℜd and an integer k, and the problem is to determine a set of k points in ℜd, called centers, to minimize the mean squared distance from each data point to its nearest center. No exact polynomial-time algorithms are known for this problem. Although asymptotically efficient approximation algorithms exist, these algorithms are not practical due to the extremely high constant factors involved. There are many heuristics that are used in practice, but we know of no bounds on their performance.We consider the question of whether there exists a simple and practical approximation algorithm for k-means clustering. We present a local improvement heuristic based on swapping centers in and out. We prove that this yields a (9+ε)-approximation algorithm. We show that the approximation factor is almost tight, by giving an example for which the algorithm achieves an approximation factor of (9-ε). To establish the practical value of the heuristic, we present an empirical study that shows that, when combined with Lloyd's algorithm, this heuristic performs quite well in practice.

In k-means clustering, we are given a set of n data points in d-dimensional space R/sup d/ and an integer k and the problem is to determine a set of k points in Rd, called centers, so as to minimize the mean squared distance from each data point to its nearest center. A popular heuristic for k-means clustering is Lloyd's (1982) algorithm. We present a simple and efficient implementation of Lloyd's k-means clustering algorithm, which we call the filtering algorithm. This algorithm is easy to implement, requiring a kd-tree as the only major data structure. We establish the practical efficiency of the filtering algorithm in two ways. First, we present a data-sensitive analysis of the algorithm's running time, which shows that the algorithm runs faster as the separation between clusters increases. Second, we present a number of empirical studies both on synthetically generated data and on real data sets from applications in color quantization, data compression, and image segmentation.

Computing discrete two-dimensional (2-D) convolutions is an important problem in image processing. In mathematical morphology, an important variant is that of computing binary convolutions, where the kernel of the convolution is a 0-1 valued function. This operation can be quite costly, especially when large kernels are involved. We present an algorithm for computing convolutions of this form, where the kernel of the binary convolution is derived from a convex polygon. Because the kernel is a geometric object, we allow the algorithm some flexibility in how it elects to digitize the convex kernel at each placement, as long as the digitization satisfies certain reasonable requirements. We say that such a convolution is valid. Given this flexibility we show that it is possible to compute binary convolutions more efficiently than would normally be possible for large kernels. Our main result is an algorithm which, given an m x n image and a k-sided convex polygonal kernel K, computes a valid convolution in O(kmn) time. Unlike standard algorithms for computing correlations and convolutions, the running time is independent of the area or perimeter of K, and our techniques do not rely on computing fast Fourier transforms. Our algorithm is based on a novel use of Bresenham's (1965) line-drawing algorithm and prefix-sums to update the convolution incrementally as the kernel is moved from one position to another across the image.

means clustering is a very popular clustering technique, which is used in numerous applications.Given a set of n data points in R d and an integer k, the problem is to determine a set of k points R d, called centers, so as to minimize the mean squared distance from each data point to its nearest center.A popular heuristic for k-means clustering is Lloyd's algorithm.In this paper we present a simple and efficient implementation of Lloyd's k-means clustering algorithm, which we call the filtering algorithm.This algorithm is very easy to implement.It differs from most other approaches in that it precomputes a kd-tree data structure for the data points rather than the center points.We establish the practical efficiency of the filtering algorithm in two ways.First, we present a data-sensitive analysis of the algorithm's running time.Second, we have implemented the algorithm and performed a number of empirical studies, both on synthetically generated data and on real data from applications in color quantization, compression, and segmentation.

Consider a set of S of n data points in real d -dimensional space, R d , where distances are measured using any Minkowski metric. In nearest neighbor searching, we preprocess S into a data structure, so that given any query point q ∈ R d , is the closest point of S to q can be reported quickly. Given any positive real ϵ, data point p is a (1 +ϵ)- approximate nearest neighbor of q if its distance from q is within a factor of (1 + ϵ) of the distance to the true nearest neighbor. We show that it is possible to preprocess a set of n points in R d in O(dn log n ) time and O(dn) space, so that given a query point q ∈ R d , and ϵ > 0, a (1 + ϵ)-approximate nearest neighbor of q can be computed in O ( c d , ϵ log n ) time, where c d,ϵ ≤ d ⌈1 + 6d/ϵ⌉ d is a factor depending only on dimension and ϵ. In general, we show that given an integer k ≥ 1, (1 + ϵ)-approximations to the k nearest neighbors of q can be computed in additional O(kd log n ) time.

Blum's medial axis transformation (MAT) for binary pictures yields medial axis points that lie midway between opposite borders of a region or along angle bisectors. This note discusses a generalization of the MAT in which a score is computed for each point P of a grayscale picture based on the gradient magnitudes at pairs of points that have P as their midpoint. These scores are high at points that lie midway between pairs of antiparallel edges or along angle bisectors, so that they define a MAT-like ``skeleton,'' which we may call the GRADMAT. However, this skeleton is rather sensitive to the presence of noise edges or to irregularities in the region edges, and it also is subject to artifacts created by pairs of edges belonging to different objects.

A simple class of piecewise constant approximations to an image is constructed as follows: start with the entire image, subdivide it into quadrants if its gray level standard deviation is high, and repeat the process for each quadrant. This yields a decomposition of the image into blocks, each having low standard deviation, so that each of them can be approximated by a constant value, namely, its mean. The histogram of this approximated image tends to have sharper peaks than that of the original image since the block averaging reduces the variability of the gray levels within homogeneous regions. A possible way of further improving the histogram is based on the fact that small blocks tend to occur near region borders; thus, suppressing these blocks should tend to deepen the valleys on the histogram, making threshold selection (to separate regions of different types) easier. Conversely, the histogram of the small blocks only represents a population of pixels near region borders, and if there are only two types of regions (e.g., objects and background), the mean of this histogram should be a useful threshold for separating them; but in practice, this method is not very reliable since background fluctuations also give rise to border pixels.

ZMOB is a multimicroprocessor system consisting of 256 Z80A microprocessors that communicate via a fast cyclic shift-register bus. This paper discusses the efficient use of ZMOB for various types of image processing operations, including point and local operations, discrete transforms, geometric operations, and computation of image statistics.

Given a binary image stored in a cellular array, a local reconfiguration process can be used to reconnect some of the cells into a quadtree network representing the image. This quadtree can also be ``roped,'' i.e., nodes representing adjacent image blocks of the same size can be joined. Using the roped quadtree network as a parallel (cellular) computer, image properties such as perimeter and genus, as well as the quadtree distance transform, can be computed in O(tree height) = O(log image diameter) time. The area and centroid of the image can be computed in O(height) time without the need for roping.

Several types of gray-weighted ``medial axes'' have been defined. This paper shows that one of them, the min-max medial axis, can be used to reconstruct good approximations to the original image based on a relatively small amount of information.

Some contour properties can be derived in parallel by a string or cycle of automata in linear time, faster than can be done with a single processor. In particular, the intersection points of two contours, the straightness of a line, the union or intersection of two contours, and polygonal approximations of a contour are computed in linear time.

A formal model for processor networks, the cellular d-graph automaton, is described, and its equivalence to Siegel's formal model for SIMD machines is discussed.

Three simple methods of extracting texture primitives are compared. It appears that the simplest of these, thresholding at a fixed percentile, yields primitives that are quite effective in texture discrimination, using a set of simple properties of the primitives. Second-order statistics of these properties were also computed for pairs of neighboring primitives, using several definitions of "neighboring." In some cases, textures not discriminable using first-order statistics can be discriminated using statistics of the second order.