A weighted bisector graph is a geometric graph whose faces are bounded by edges that are portions of multiplicatively weighted bisectors of pairs of (point) sites such that each of its faces is defined by exactly one site. A prominent example of a bisector graph is the multiplicatively weighted Voronoi diagram of a finite set of points which induces a tessellation of the plane into Voronoi faces bounded by circular arcs and straight-line segments. Several algorithms for computing various types of bisector graphs are known. In this paper we reverse the problem: Given a partition G of the plane into faces, find a set of points and suitable weights such that G is a bisector graph of the weighted points, if a solution exists. If G is a graph that is regular of degree three then we can decide in O(m) time whether it is a bisector graph, where m denotes the combinatorial complexity of G. In the same time we can identify up to two candidate solutions such that G could be their multiplicatively weighted Voronoi diagram. Additionally, we show that it is possible to recognize G as a multiplicatively weighted Voronoi diagram and find all possible solutions in O(mlog⁡m) time if G is given by a set of disconnected lines and circles.

We present Cgal implementations of two algorithms for computing straight skeletons in the plane, based on exact arithmetic. One code, named Surfer2, can handle multiplicatively weighted planar straight-line graphs (PSLGs) while our second code, Monos, is specifically targeted at monotone polygons. Both codes are available on GitHub. We discuss algorithmic as well as implementational and engineering details of both codes. Furthermore, we present the results of an extensive performance evaluation in which we compared Surfer2 and Monos to the straight-skeleton package included in Cgal. It is not surprising that our special-purpose code Monos outperforms Cgal's straight-skeleton implementation. But our tests provide ample evidence that also Surfer2 can be expected to be faster and to consume significantly less memory than the Cgal code. And, of course, Surfer2 is more versatile because it can handle multiplicative weights and general PSLGs as input. Thus, Surfer2 currently is the fastest and most general straight-skeleton code available.

Our work on minimum convex decompositions is based on two key components: (1) different strategies for computing initial decompositions, partly adapted to the characteristics of the input data, and (2) local optimizations for reducing the number of convex faces of a decomposition. We discuss our main heuristics and show how they helped to reduce the face count.

We present Cgal implementations of two algorithms for computing straight skeletons in the plane, based on exact arithmetic. One code, named Surfer2, can handle multiplicatively weighted planar straight-line graphs (PSLGs) while our second code, Monos, is specifically targeted at monotone polygons. Both codes are available on GitHub. We discuss algorithmic as well as implementational and engineering details of both codes. Furthermore, we present the results of an extensive performance evaluation in which we compared Surfer2 and Monos to the straight-skeleton package included in Cgal. It is not surprising that our special-purpose code Monos outperforms Cgal’s straight-skeleton implementation. But our tests provide ample evidence that also Surfer2 can be expected to be faster and to consume significantly less memory than the Cgal code. And, of course, Surfer2 is more versatile because it can handle multiplicative weights and general PSLGs as input. Thus, Surfer2 currently is the fastest and most general straight-skeleton code available.

We present two software packages for computing straight skeletons: Monos, our implementation of an algorithm by Biedl et al. (2015), computes the straight skeleton of a monotone input polygon, and Surfer2 implements a generalization of an algorithm by Aichholzer and Aurenhammer (1998) to handle multiplicatively-weighted planar straight-line graphs as input. The graphical user interfaces that ship with our codes support step-by-step computations, where each event can be investigated and studied by the user. This makes them a canonical candidate for educational purposes and detailed event analyses. Both codes are freely available on GitHub.

We present a simple wavefront-like approach for computing multiplicatively weighted Voronoi diagrams of points and straight-line segments in the Euclidean plane. If the input sites may be assumed to be randomly weighted points then the use of a so-called overlay arrangement [Har-Peled&Raichel, Discrete Comput. Geom. 53:547-568, 2015] allows to achieve an expected runtime complexity of $O(n\log^4 n)$, while still maintaining the simplicity of our approach. We implemented the full algorithm for weighted points as input sites, based on CGAL. The results of an experimental evaluation of our implementation suggest $O(n\log^2 n)$ as a practical bound on the runtime. Our algorithm can be extended to handle also additive weights in addition to multiplicative weights, and it yields a truly simple $O(n\log n)$ solution for solving the one-dimensional version of this problem.

We present an experimental study of strategies for triangulating polygons in parallel on multi-core machines, including the parallel computation of constrained Delaunay triangulations. As usual, we call three consecutive vertices of a (planar) polygon an ear if the triangle that is spanned by them is completely inside the polygon. Extensive tests on thousands of sample polygons indicate that about 50% of vertices of most polygons form ears. This experimental result suggests that polygon-triangulation algorithms based on ear clipping might be well-suited for parallelization. We discuss three different approaches to parallelizing ear clipping, and we present a parallel edge-flipping algorithm for converting a triangulation into a constrained Delaunay triangulation. All algorithms were implemented as part of Held's FIST framework. We report on our experimental findings, which show that the most promising method achieves an average speedup of 2–3 on a quad-core processor. In any case, our new triangulation code is faster than the sequential triangulation codes Triangle (by Shewchuk) and FIST.

We extend the work by Huber and Held (IJCGA 2012) on straight-skeleton computation based on motorcycle graphs to positively weighted skeletons. Resorting to a line arrangement induced by the r reflex vertices of a simple n-vertex polygon P allows to compute the weighted straight skeleton of P in O(n2+r3k+nrlog⁡n) time and O(n+kr) space, for an arbitrary positive integer k≤r.

We introduce additively-weighted straight skeletons as a new generalization of straight skeletons. An additively-weighted straight skeleton is the result of a wavefront-propagation process where, unlike in previous variants of straight skeletons, wavefront edges do not necessarily begin to move at the start of the propagation process but at later points in time. We analyze the properties of additively-weighted straight skeletons and show how to compute straight skeletons with both additive and multiplicative weights, i.e., where input edges are allowed to move at different speeds and may start at different times. We then show how to use additively-weighted and multiplicatively-weighted straight skeletons to generate roofs and terrains for polygonal shapes such as the footprints of buildings or river networks. As a result, we are able to automatically generate roofs and terrains where the individual facets have different inclinations and may start at different heights.

We investigate weighted straight skeletons from a geometric, graph-theoretical, and combinatorial point of view. We start with a thorough definition and shed light on some ambiguity issues in the procedural definition. We investigate the geometry, combinatorics, and topology of faces and the roof model, and we discuss in which cases a weighted straight skeleton is connected. Finally, we show that the weighted straight skeleton of even a simple polygon may be non-planar and may contain cycles, and we discuss under which restrictions on the weights and/or the input polygon the weighted straight skeleton still behaves similar to its unweighted counterpart. In particular, we obtain a non-procedural description and a linear-time construction algorithm for the straight skeleton of strictly convex polygons with arbitrary weights.

We investigate weighted straight skeletons from a geometric, graph-theoretical, and combinatorial point of view. We start with a thorough definition and shed light on some ambiguity issues in the procedural definition. We investigate the geometry, combinatorics, and topology of faces and the roof model, and we discuss in which cases a weighted straight skeleton is connected. Finally, we show that the weighted straight skeleton of even a simple polygon may be non-planar and may contain cycles, and we discuss under which restrictions on the weights and/or the input polygon the weighted straight skeleton still behaves similar to its unweighted counterpart. In particular, we obtain a non-procedural description and a linear-time construction algorithm for the straight skeleton of strictly convex polygons with arbitrary weights.

We study the characteristics of straight skeletons of monotone polygonal chains and use them to devise an algorithm for computing positively weighted straight skeletons of monotone polygons. Our algorithm runs in O(nlog⁡n) time and O(n) space, where n denotes the number of vertices of the polygon.

Delay insensitive asynchronous circuitry provides significant advantages with respect to substrate noise due to localized switching. The differences between the substrate noise from NULL convention logic (NCL) and traditional clocked Boolean logic (CBL) are described and analyzed based on measured results. A test chip fabricated in the TSMC 0.25 μm process shows that a pseudo-random number generator implemented with NCL generates 23 dB less substrate noise compared to the equivalent synchronous design. In a larger scale digital circuit, the substrate noise improvement offered by an asynchronous 8051 processor over its synchronous counterpart was nearly 10 dB. The effect of this substrate noise on an analog circuit was explored with a delta-sigma modulator (DSM) example. The signal-to-noise ratio performance of a second order DSM was not affected by the substrate noise from the NCL 8051 processor while it experiences up to 15 dB degradation when the CBL 8051 processor is clocked near integer multiples of the DSM sampling frequency.

We study straight skeletons and make both theoretical and practical contributions which support new approaches to the computation of straight skeletons of arbitrary planar straight-line graphs (PSLGs). We start with an adequate extension of the concept of motorcycle graphs to PSLGs, with motorcycles starting at the reflex vertices of a PSLG, which allows us to generalize well-known results on the relation between the straight skeleton and the motorcycle graph to arbitrary PSLGs: the edges of the motorcycle graph cover a specific subset of the edges of the straight skeleton, and they form the basis of 3D slabs such that the projection of the lower envelope of those slabs to the plane forms the straight skeleton. As an immediate application we sketch how to use a graphics hardware for computing (approximate) straight skeletons of PSLGs. Further, we present and analyze a novel wavefront-type algorithm which bridges the current gap between the theory and practice of straight-skeleton computations. Our algorithm handles arbitrary PSLGs, is easy to implement, and is fast enough to handle complex data: it can be expected to run in O(n log n) time in practice for an n-vertex PSLG; its worst-case complexity is O(n2 log n). Extensive experimental results confirm an average runtime of 20 n log n µs on a standard PC for virtually all of our 13500 datasets of different characteristics. As also confirmed by our experiments, this constitutes an average gain in performance by a multiplicative factor of n, or at least one to two orders of magnitude, relative to the speed of the implementation provided by CGAL for closed polygons.

We study the watermarking of 2D vector data and introduce a framework which preserves topological properties of the input. Our framework is based on so-called maximum perturbation regions (MPR) of the input vertices, which is a concept similar to the just-noticeable-difference constraint. The MPRs are computed by means of the Voronoi diagram of the input and allow us to avoid (self-)intersections of input objects that might result from the embedding of the watermark. We demonstrate and analyze the applicability of this new framework by coupling it with a well-known approach to watermarking that is based on Fourier descriptors. However, our framework is general enough such that any robust scheme for the watermarking of vector data can be applied.

A fundamental algorithmic problem in computer graphics is that of computing a succinct encoding of a triangulation of a polygonal surface model in order to be able to transmit and render it efficiently.The goal is to take a given polygonal surface model, whose facets are given by (possibly multiply-connected) polygons, triangulate its facets, and then decompose the triangulation into a small number of "tristrips," each of which has its connectivity stored implicitly in the ordering of the data points.We develop methods that are effective in solving the stripification problem, both in theory (provably good encodings) and in practice.Our methods are based on carefully constructed search trees in the dual graph, followed by algorithms to decompose dual trees into tristips.One decomposition algorithm is provably optimal (based on dynamic programming), allowing us a sound basis of comparison among our other (heuristic) algorithms.We demonstrate the speed and effectiveness of our algorithms through a battery of experiments.In comparison with the recently released STRIPE system for stripification, we find that our stripifier, FTSG, produces comparable or better quality encodings, while requiring significantly less computing time on a large variety of datasets.Further, FTSG is carefully engineered and implemented to be robust, even in the face of highly degenerate and corrupted real-world data.

The author discusses a triangulation algorithm that is based on repeatedly clipping ears of a polygon. The main focus of the work was on designing an algorithm that is (1) completely reliable, (2) easy to implement, and (3) fast in practice. The algorithm was implemented in ANSI C, based on floating-point arithmetic. Due to a series of heuristics that get applied as a back-up for the standard ear-clipping process if the code detects deficiencies in the input polygon, the triangulation code can handle any type of polygonal input data, be it simple or not. Based on his implementation he reports on different strategies (geometric hashing, bounding volume trees) for speeding up the ear-clipping process in practice. The code has been tuned accordingly, and CPU-time statistics document that it tends to be faster than other popular triangulation codes. The code forms the core of a package for triangulating the faces of 3D polyhedra, and it has been successfully incorporated into two industrial graphics packages.

Collision detection is of paramount importance for many applications in computer graphics and visualization. Typically, the input to a collision detection algorithm is a large number of geometric objects comprising an environment, together with a set of objects moving within the environment. In addition to determining accurately the contacts that occur between pairs of objects, one needs also to do so at real-time rates. Applications such as haptic force feedback can require over 1000 collision queries per second. We develop and analyze a method, based on bounding-volume hierarchies, for efficient collision detection for objects moving within highly complex environments. Our choice of bounding volume is to use a discrete orientation polytope (k-DOP), a convex polytope whose facets are determined by halfspaces whose outward normals come from a small fixed set of k orientations. We compare a variety of methods for constructing hierarchies (BV-trees) of bounding k-DOPs. Further, we propose algorithms for maintaining an effective BV-tree of k-DOPs for moving objects, as they rotate, and for performing fast collision detection using BV-trees of the moving objects and of the environment. Our algorithms have been implemented and tested. We provide experimental evidence showing that our approach yields substantially faster collision detection than previous methods.

No abstract available.