Lee R. Nackman

Efficient Delaunay triangulation using rational arithmetic

Many fundamental tests performed by geometric algorithms can be formulated in terms of finding the sign of a determinant. When these tests are implemented using fixed precision arithmetic such as floating point, they can produce incorrect answers; when they are implemented using arbitrary-precision arithmetic, they are expensive to compute. We present adaptive-precision algorithms for finding the signs of determinants of matrices with integer and rational elements. These algorithms were developed and tested by integrating them into the Guibas-Stolfi Delaunay triangulation algorithm. Through a combination of algorithm design and careful engineering of the implementation, the resulting program can triangulate a set of random rational points in the unit circle only four to five times slower than can a floating-point implementation of the algorithm. The algorithms, engineering process, and software tools developed are described.

Automatic mesh generation using the symmetric axis transformation of polygonal domains

An automatic method for generating finite element meshes for multiply connected planar domains with polygonal boundaries (i.e. planar polygons with polygonal holes) is described. The symmetric axis transform is used to obtain a planar graph that partitions the given domain. This transformation may introduce edges in the graph that are too long or too short for generating good meshes. A silver processing algorithm, which transforms the graph into another graph devoid of such edges, is presented. Finally, additional modes are placed on the edges of the graph to obtain a triangulation, and this process is applied iteratively, yielding the final mesh. The method automatically increases the mesh density in regions of rapid change in shape and allows both global and local control of the mesh density. The method also admits the imposition of node compatibility constraints along domain boundaries, thus making the method suitable for meshing planar cell complexes (i.e multiple polygonal domains with shared boundaries in two-dimensional space) and for generating boundary elements for polyhedra in three-dimensional space. >

Voronoi diagram for multiply-connected polygonal domains 1: algorithm

Voronoi diagrams of multiply-connected polygonal domains (polygons with holes) can be of use in computer-aided design. We describe a simple algorithm that computes such Voronoi diagrams in O(N(log 2 N+H)) time, where N is the number of edges and H is the number of holes.

Saving legacy with objects

Developers of application software must often work with “legacy systems.” These are systems that have evolved over many years and are considered irreplaceable, either because it is thought that duplicating their function would be too expensive, or because they are trusted by users. Because of their age, such systems are likely to have been implemented in a conventional language with limited use of data abstraction or encapsulation. The lack of abstraction complicates adding new applications to such systems and the lack of encapsulation impedes modifying the system because applications depend on system internals. We describe our experience providing and using an object-oriented interface to a legacy system.

TGMS: an object-oriented system for programming geometry

TGMS (tiered geometric modelling system) is an experimental system intended to reduce the difficulty and cost of developing new solid modelling applications while preserving investment in an existing, time‐tested, solid modeller. The application developer writes programs in the TGMS language, which consists of a base language augmented by data types (classes) for geometry. The base programming language is AML/X, an object‐oriented language intended for use in design and manufacturing applications. Solid modelling is done using an interface to GDP (geometric design processor), an existing, production‐quality solid modelling system. TGMS shows how a system written in a non‐object‐oriented language can be used as a base for an object‐oriented application programming environment.

Visualization of Three-Dimensional Delaunay Meshes

Abstract. We describe an algorithm for the rapid display of three-dimensional Delaunay meshes (or selected portions thereof) on standard raster displays, without the use of special purpose graphics hardware. The algorithm allows the display of the interior structure as well as the surface of the mesh, and furthermore does not require that the meshed domain be convex, or even connected. The algorithm computes a depth ordering on the mesh elements. This ordering can be used to display subsets of the mesh, as well as isosurfaces induced by fields represented on the mesh. Furthermore, by utilizing mesh coherence, the depth ordering can be used to view the mesh from front to back as well as back to front. An implementation of the algorithm has been incorporated in a system for designing and analyzing the performance of three-dimensional semiconductor and electronic packaging structures. The system is in regular use and the mesh-display algorithm has been used to visualize both meshes and fields computed over the meshes.

Semiconductor wafer representation for TCAD

This work describes the Semiconductor Wafer Representation (SWR) for representing and manipulating wafer state during process and device simulation. The goal of the SWR is to provide an object-oriented interface to a collection of functions designed for developing and integrating Technology CAD (TCAD) applications. By providing functions which can be common across many applications, we aim to greatly reduce tool development and integration time. Corporate, vendor, and university TCAD developers have worked together under the auspices of the CAD Framework Initiative to create an architecture and C++ programming interface for an SWR 1.0 draft standard. Here we describe this architecture and the results of creating and using a prototype implementation of the standard both to integrate existing TCAD tools and to develop simple new tools. >

The active deallocation of objects in object-oriented systems

In object‐oriented systems, it is oftern useful for objects to be allowed to carry out some action before they are deallocated. This can be done by defining a destroy method in the objects class, and arranging for the memory system to send a message invoking this method immediately before deallocating the object. This allows resources associated with the object to be returned to the system, limited cross‐language garbage collection, and other, more complex, behaviour. During the execution of the destroy method it is possible for new references to objects to be created. Care must be taken that the garbage collection does not erroneously free such objects. Algorithms are presented to implement destroy methods in systems using reference counting and mark‐scan garbage collection techniques. Properties that are desirable in such systems are also discussed.

Bisectors of linearly separable sets

A bisector of two sets is the set of points equidistant form them. Bisectors arise naturally in several areas of computational geometry. We show that bisectors of weakly linearly separable sets inEd have many properties of interest. Among these, the bisector of a restricted class of linearly separated sets is a homeomorphic image of the linear separator. We also give necessary and sufficient conditions for the existence of a particular continuous map from (a portion of) any linear separator to the bisector.

Software environments for CAD systems

A high-level structure for a CAD modelling system development environment is proposed based on the thesis that domain independent and domain dependent modelling system functions can and should be separated. The thesis is supported by example functions drawn from a solid modelling system and a VLSI layout system.