Christopher J. Van Wyk

Efficient exact arithmetic for computational geometry

We experiment with exact integer arithmetic to implement primitives for geometric algorithms. Naive use of exact arithmetic—either modular or multiprecision integer—increases execution time dramatically over the use of floating-point arithmetic. By combining tuned multiprecision integer arithmetic and a floating-point filter based on interval analysis, we can obtain the effect of exact integer arithmetic at a cost close to that of floating-point arithmetic. We describe an experimental expression compiler that conveniently packages our techniques.

Static analysis yields efficient exact integer arithmetic for computational geometry

Geometric algorithms are usually described assuming that arithmetic operations are performed exactly on real numbers. A program implemented using a naive substitution of floating-point arithmetic for real arithmetic can fail, since geometric primitives depend upon sign-evaluation and may not be reliable if evaluated approximately. Geometric primitives are reliable if evaluated exactly with integer arithmetic, but this degrades performance since software extended-precision arithmetic is required.

An automatic beautifier for drawings and illustrations

We describe a method for inferring constraints that are desirable for a given (rough) drawing and then modifying the drawing to satisfy the constraints wherever possible. The method has been implemented as part of an online graphics editor running under the UNIX™ operating system and it has undergone modifications in response to user input. Although the framework we discuss is general, the current implementation is polygon-oriented. The relations examined are: approximate equality of the slope or length of sides, collinearity of sides, and vertical and horizontal alignment of points.

A High-Level Language for Specifying Pictures

A programming language tha t includes special constructs for drawing pictures is discussed. The language has been designed so that programs to draw pictures can reflect the structure of those pictures. Picture elements are called boxes. They are defmed by declaring algebraic relationships tha t should exist among their significant points and requesting actions to be performed at those points. The algebraic relationships are processed by an equation solver to determine the absolute location of significant points. A new mechanism of variable reference and scope makes the expression of relationships tha t should exist among picture elements more direct than it is in conventional languages. Some common picture operations--drawing lines using a pattern, filling in areas with textures, and obscuring parts of a picture by other par ts--are all expressed readily once the mechanism for defining and using boxes is in place. The language has been implemented, and used by several authors to prepare figures for their papers and books. It was also used to prepare this paper.

A fast las vegas algorithm for triangulating a simple polygon

We present a randomized algorithm that triangulates a simple polygon onn vertices inO(n log*n) expected time. The averaging in the analysis of running time is over the possible choices made by the algorithm; the bound holds for any input polygon.

Goalie: A Space Efficient System for VLSI Artwork Analysis

Advances in VLSI have resulted in more and more complex circuitry, fueling the need for programs that analyze IC mask artwork. This article describes Goalie, an artwork analysis system, by explaining the algorithms used to support circuit extraction, Boolean geometric operations, connectivity analysis, capacitance measurement and design checking. Tests on several systems have shown that Goalie runs at least as fast as algorithms currently in use, but it requires less main memory, so large layouts can be handled on small computers, or even on personal workstations.

Space Efficient Algorithms for VLSI Artwork Analysis

We present algorithms for performing connectivity analysis, transistor identification, and boolean geometric operations with region numbering. Previous methods all require O(n) space where n is the number of edges in the circuit artwork; our method takes only O(√n) space and can therefore handle circuits of any foreseeable size. Our algorithms are based on traditional scanline techniques in such a way that any implementation of our method will be at least as fast, as well as more compact. Statistics on one such implementation are presented.

Convex hulls of piecewise-smooth Jordan curves

Abstract Several linear-time algorithms for finding the convex hull of a simple polygon in the plane are known. This paper extends a linear-time algorithm for polygons to a linear-time algorithm for input that includes smooth, convex, curved edges, such as conic sections.

Decomposition and intersection of simple splinegons

A splinegon is a polygon whose edges have been replaced by “well-behaved” curves. We show how to decompose a simple splinegon into a union of monotone pieces and into a union of differences of unions of convex pieces. We also show how to use a fast triangulation algorithm to test whether two given simple splinegons intersect. We conclude with examples of splinegons that make the extension of algorithms from polygons to splinegons difficult.

A graphics typesetting language

We present a new programming language, IDEAL, in which two-dimensional figures can be expressed. The language is intended to work with existing text-formatting systems so that text and figures can be typeset at the same time. The building block for IDEAL programs is called a “box” it shares some features with procedures and some with records in general-purpose programming languages. A box includes a system of constraints (in this incarnation, equations in complex variables) that declares the relative positions of its significant points and requests for actions to be performed at those points. A box is called by adding enough constraints to the system in its definition that its significant points can be solved for uniquely. A box call may also include additional actions to be performed during the call. The notions of drawing a line using a pattern and texturing a polygonal area follow directly from the mechanism for defining and calling boxes. Users may also ask for a box to be “opaque” so that it blots out pieces of picture that it covers. Finally, two commands embody the idea of sketching several pictures on different parallel planes, then merging them into a single picture. We use these when erasing to create one part of a picture would destroy another part that we want. We discuss good algorithms for implementing IDEAL when the constraints are expressed as a special kind of nonlinear system and the pictures are composed of straight lines and circular arcs. The language has been implemented, and was used to produce the paper.