Joseph Gil

Linear time Euclidean distance transform algorithms

Two linear time (and hence asymptotically optimal) algorithms for computing the Euclidean distance transform of a two-dimensional binary image are presented. The algorithms are based on the construction and regular sampling of the Voronoi diagram whose sites consist of the unit (feature) pixels in the image. The first algorithm, which is of primarily theoretical interest, constructs the complete Voronoi diagram. The second, more practical, algorithm constructs the Voronoi diagram where it intersects the horizontal lines passing through the image pixel centers. Extensions to higher dimensional images and to other distance functions are also discussed. >

Spider Diagrams

Spider diagrams combine and extend Venn diagrams and Euler circles to express constraints on sets and their relationships with other sets. These diagrams can be used in conjunction with object-oriented modelling notations such as the Unified Modelling Language. This paper summarises the main syntax and semantics of spider diagrams. It also introduces inference rules for reasoning with spider diagrams and a rule for combining spider diagrams. This system is shown to be sound but not complete. Disjunctive diagrams are considered as one way of enriching the system to allow combination of diagrams so that no semantic information is lost. The relationship of this system of spider diagrams to other similar systems, which are known to be sound and complete, is explored briefly.

Micro patterns in Java code

Micro patterns are similar to design patterns, except that micro patterns are stand at a lower, closer to the implementation, level of abstraction. Micro patterns are also unique in that they are mechanically recognizable, since each such pattern can be expressed as a formal condition on the structure of a class.This paper presents a catalog of 27 micro-patterns defined on Java classes and interfaces. The catalog captures a wide spectrum of common programming practices, including a particular and (intentionally restricted) use of inheritance, immutability, data management and wrapping, restricted creation, and emulation of procedural-, modular-, and even functional- programming paradigms with object oriented constructs. Together, the patterns present a set of prototypes after which a large portion of all Java classes and interfaces are modeled. We provide empirical indication that this portion is as high as 75%.A statistical analysis of occurrences of micro patterns in a large software corpus, spanning some 70,000 Java classes drawn from a rich set of application domains, shows, with high confidence level that the use of these patterns is not random. These results indicate consciousness and discernible design decisions, which are sustained in the software evolution. With high confidence level, we can also show that the use of these patterns is tied to the specification, or the purpose, that the software realizes.The traceability, abundance and the statistical significance of micro pattern occurrence raise the hope of using the classification of software into these patterns for a more founded appreciation of its design and code quality.

Computing 2-D min, median, and max filters

Fast algorithms for computing min, median, max, or any other order statistic filter transforms are described. The algorithms take constant time per pixel to compute min or max filters and polylog time per pixel, in the size of the filter, to compute the median filter. A logarithmic time per pixel lower bound for the computation of the median filter is shown. >

Efficient dilation, erosion, opening, and closing algorithms

We propose an efficient and deterministic algorithm for computing the one-dimensional dilation and erosion (max and min) sliding window filters. For a p-element sliding window, our algorithm computes the 1D filter using 1.5 + o(1) comparisons per sample point. Our algorithm constitutes a deterministic improvement over the best previously known such algorithm, independently developed by van Herk (1992) and by Gil and Werman (1993) (the HGW algorithm). Also, the results presented in this paper constitute an improvement over the Gevorkian et al. (1997) (GAA) variant of the HGW algorithm. The improvement over the GAA variant is also in the computation model. The GAA algorithm makes the assumption that the input is independently and identically distributed (the i.i.d. assumption), whereas our main result is deterministic. We also deal with the problem of computing the dilation and erosion filters simultaneously, as required, e.g., for computing the unbiased morphological edge. In the case of i.i.d. inputs, we show that this simultaneous computation can be done more efficiently then separately computing each. We then turn to the opening filter, defined as the application of the min filter to the max filter and give an efficient algorithm for its computation. Specifically, this algorithm is only slightly slower than the computation of just the max filter. The improved algorithms are readily generalized to two dimensions (for a rectangular window), as well as to any higher finite dimension (for a hyperbox window), with the number of comparisons per window remaining constant. For the sake of concreteness, we also make a few comments on implementation considerations in a contemporary programming language.

Precise specification and automatic application of design patterns

Despite vast interest in design patterns, the specification and application of patterns is generally assumed to rely on manual implementation. We describe a precise method of specifying how a design pattern is applied: by phrasing it as an algorithm in a meta-programming language. We present a prototype of a tool that supports the specification of design patterns and their realization in a given program. Our prototype allows automatic application of design patterns without obstructing the source code test from the programmer, who may edit it at will. We demonstrate pattern specification in meta-programming techniques and a sample outcome of its application.

Towards a theory of nearly constant time parallel algorithms

It is demonstrated that randomization is an extremely powerful tool for designing very fast and efficient parallel algorithms. Specifically, a running time of O(lg* n) (nearly-constant), with high probability, is achieved using n/lg* n (optimal speedup) processors for a wide range of fundamental problems. Also given is a constant time algorithm which, using n processors, approximates the sum of n positive numbers to within an error which is smaller than the sum by an order of magnitude. A variety of known and new techniques are used. New techniques, which are of independent interest, include estimation of the size of a set in constant time for several settings, and ways for deriving superfast optimal algorithms from superfast nonoptimal ones.<<ETX>>

Polynomial hash functions are reliable

Polynomial hash functions are well studied and widely used in various applications. They have gained popularity because of certain performances they exhibit. It has been shown that even linear hash functions are expected to have such performances. However, quite often we would like the hash functions to be reliable, meaning that they perform well with high probability; for some certain important properties even higher degree polynomials were not known to be reliable. We show that for certain important properties linear hash functions are not reliable. We give indication that quadratic hash functions might not be reliable. On the positive side, we prove that cubic hash functions are reliable. In a more general setting, we show that higher degree of the polynomial hash functions translates into higher reliability. We also introduce a new class of hash functions, which enables to reduce the universe size in an efficient and simple manner. The reliability results and the new class of hash functions are used for some fundamental applications: improved and simplified reliable algorithms for perfect hash functions and real-time dictionaries, which use significantly less random bits, and tighter upper bound for the program size of perfect hash functions.

Formalizing spider diagrams

Geared to complement UML and the specification of large software systems by non-mathematicians, spider diagrams are a visual language that generalizes the popular and intuitive Venn diagrams and Euler circles. The language design emphasizes scalability and expressiveness while retaining intuitiveness. In this paper, we describe spider diagrams from a mathematical standpoint and show how their formal semantics can be made in terms of logical expressions. We also claim that all spider diagrams are self-consistent.

Geometric medians

We discuss several generalizations of the notion of median to points in