We give a deterministic algorithm for triangulating a simple polygon in linear time. The basic strategy is to build a coarse approximation of a triangulation in a bottom-up phase and then use the information computed along the way to refine the triangulation in a top-down phase. The main tools used are the polygon-cutting theorem, which provides us with a balancing scheme, and the planar separator theorem, whose role is essential in the discovery of new diagonals. Only elementary data structures are required by the algorithm. In particular, no dynamic search trees, of our algorithm.

Triangulating a simple polygon in linear time

Computer systems commonly cache the values of variables to gain efficiency. In applications where the goal is to track attributes of a continuously moving or deforming physical system over time, caching relations between variables works better than caching individual values. The reason is that, as the system evolves, such relationships are more stable than the values of individual variables.Kinetic data structures (KDSs) are a novel formal framework for designing and analyzing sets of assertions to cache about the environment, so that these assertion sets are at once relatively stable and tailored to facilitate or trivialize the computation of the attribute of interest. Formally, a KDS is a mathematical proof animated through time, proving the validity of a certain computation for the attribute of interest. KDSs have rigorous associated measures of performance and their design shares many qualities with that of classical data structures.The KDS framework has led to many new and promising algorithms in applications where the efficient modeling of motion is essential. Among these are collision detection for moving rigid and deformable bodies, connectivity maintenace in ad-hoc networks, local environment tracking for mobile agents, and visibility/occlusion maintenance. This talk will survey the general ideas behind KDSs and illustrate their application to simple geometric problems that arise in virtual and physical environments.

Data structures for mobile data (invited talk) (abstract only)

We want to express digital communication with a human touch. So we pay attention to the properties of a door because it links one place to another. We think the linking of different places and sharing of places is one of the substantial qualities of network technology. Another reason that we focus on a door is because it bears great meanings. For example, a door is the first spot for a meeting with someone or for kissing someone goodbye. It could be your children, spouse, or your friends. These days, we talk and say hello to friends by Messenger or mobiles. Accustomed to digital devices which neglect time or space, we expect that the devices can carry our emotions to others. However, these have limits in expression. We want to show through the our work "The Door" that network technology should have a little more humanity and love in the near future.

The Door

The development of complex embedded control systems can be improved significantly by applying formal techniques from control engineering and software engineering. It is shown how these approaches can be combined to improve the design and analysis of high-tech systems, both in theory and practice. The semantics of the integration of two established rigorous techniques has been defined formally in this work. The strength of this integrated semantics is demonstrated by means of a significant industrial case study: the embedded control of a printer paper path, whereby the full development life-cycle from model to realization is covered. The resulting model-driven design approach fits the current engineering practice in industry and is both flexible and effective.

/pdf/modeling-and-validating-distributed-embedded-real-time-16joxhm2rn.pdf

Modeling and validating distributed embedded real-time control systems

Quantitative model checking has become an indispensable tool 
to analyze performance and dependability characteristics 
such as the expected round trip time in a packet switched network 
or the failure probability of a safety-critical system.

So far, the existing model checking techniques lack support for models
which combine stochastic timing and nondeterminism. This is surprising,
as nondeterminism is the key for compositional modeling and occurs 
naturally in distributed systems. 

In this thesis, we overcome this limitation. More precisely,
we consider continuous-time Markov decision processes (CTMDPs),
a model which closely entangles stochasticity and nondeterminism. 
Our main contribution is a discretization which allows to compute 
the maximum and minimum probability to enter a set of goal states 
in a CTMDP within a given time-bound.
By applying value iteration techniques to the induced discrete-time model, 
we compute the desired probabilities up to an a priori specified precision.

This result provides the basis for model checking important performance 
and dependability characteristics and has been extended to a variety of 
other nondeterministic and randomly timed system models.

We demonstrate the applicability of our techniques by a number of 
case studies which also show that nondeterministic modeling makes
an essential difference in the area of performance and dependability 
evaluation.

/pdf/model-checking-nondeterministic-and-randomly-timed-systems-2rpoci7op9.pdf

Model checking nondeterministic and randomly timed systems

Computational geometry is the branch of theoretical computer science that deals with algorithms and data structures for geometric objects. The most basic geometric objects include points, lines, polygons, and polyhedra. Computational geometry has applications in many areas of computer science, including computer graphics, robotics, and geographic information systems. In many computational-geometry problems, the theoretical worst case is achieved by input that is in some way "unrealistic". This causes situations where the theoretical running time is not a good predictor of the running time in practice. In addition, algorithms must also be designed with the worst-case examples in mind, which causes them to be needlessly complicated. In recent years, realistic input models have been proposed in an attempt to deal with this problem. The usual form such solutions take is to limit some geometric property of the input to a constant. We examine a specific realistic input model in this thesis: the model where objects are restricted to be fat. Intuitively, objects that are more like a ball are more fat, and objects that are more like a long pole are less fat. We look at fat objects in the context of five different problems—two related to decompositions of input objects and three problems suggested by computer graphics. Decompositions of geometric objects are important because they are often used as a preliminary step in other algorithms, since many algorithms can only handle geometric objects that are convex and preferably of low complexity. The two main issues in developing decomposition algorithms are to keep the number of pieces produced by the decomposition small and to compute the decomposition quickly. The main question we address is the following: is it possible to obtain better decompositions for fat objects than for general objects, and/or is it possible to obtain decompositions quickly? These questions are also interesting because most research into fat objects has concerned objects that are convex. We begin by triangulating fat polygons. The problem of triangulating polygons—that is, partitioning them into triangles without adding any vertices—has been solved already, but the only linear-time algorithm is so complicated that it has never been implemented. We propose two algorithms for triangulating fat polygons in linear time that are much simpler. They make use of the observation that a small set of guards placed at points inside a (certain type of) fat polygon is sufficient to see the boundary of such a polygon. We then look at decompositions of fat polyhedra in three dimensions. We show that polyhedra can be decomposed into a linear number of convex pieces if certain fatness restrictions aremet. We also show that if these restrictions are notmet, a quadratic number of pieces may be needed. We also show that if we wish the output to be fat and convex, the restrictions must be much tighter. We then study three computational-geometry problems inspired by computer graphics. First, we study ray-shooting amidst fat objects from two perspectives. This is the problem of preprocessing data into a data structure that can answer which object is first hit by a query ray in a given direction from a given point. We present a new data structure for answering vertical ray-shooting queries—that is, queries where the ray’s direction is fixed—as well as a data structure for answering ray-shooting queries for rays with arbitrary direction. Both structures improve the best known results on these problems. Another problem that is studied in the field of computer graphics is the depth-order problem. We study it in the context of computational geometry. This is the problem of finding an ordering of the objects in the scene from "top" to "bottom", where one object is above the other if they share a point in the projection to the xy-plane and the first object has a higher z-value at that point. We give an algorithm for finding the depth order of a group of fat objects and an algorithm for verifying if a depth order of a group of fat objects is correct. The latter algorithm is useful because the former can return an incorrect order if the objects do not have a depth order (this can happen if the above/below relationship has a cycle in it). The first algorithm improves on the results previously known for fat objects; the second is the first algorithm for verifying depth orders of fat objects. The final problem that we study is the hidden-surface removal problem. In this problem, we wish to find and report the visible portions of a scene from a given viewpoint—this is called the visibility map. The main difficulty in this problem is to find an algorithm whose running time depends in part on the complexity of the output. For example, if all but one of the objects in the input scene are hidden behind one large object, then our algorithm should have a faster running time than if all of the objects are visible and have borders that overlap. We give such an algorithm that improves on the running time of previous algorithms for fat objects. Furthermore, our algorithm is able to handle curved objects and situations where the objects do not have a depth order—two features missing from most other algorithms that perform hidden surface removal.

/pdf/algorithms-for-fat-objects-decompositions-and-applications-4dlxmauk4o.pdf

Algorithms for Fat Objects: Decompositions and Applications

We present a data structure for ray-shooting queries in a set of convex fat polyhedra of total complexity n in R^3. The data structure uses O(n^2^+^@e) storage and preprocessing time, and queries can be answered in O(log^2n) time. A trade-off between storage and query time is also possible: for any m with n

Ray shooting and intersection searching amidst fat convex polyhedra in 3-space

We study the problem of cutting a set of rods (line segments in ℝ3) into fragments, using a minimum number of cuts, so that the resulting set of fragments admits a depth order. We prove that this problem is NP-complete, even when the rods have only three distinct orientations. We also give a polynomial-time approximation algorithm with no restriction on rod orientation that computes a solution of size O(τ log τ log log τ), where τ is the size of an optimal solution.

Cutting cycles of rods in space: hardness and approximation

We present a data structure for ray-shooting queries in a set of convex fat polyhedra of total complexity n in R3. The data structure uses O(n2+e) storage and preprocessing time, and queries can be answered in O(log2 n) time. A trade-off between storage and query time is also possible: for any m with n 2, we can construct a structure that uses O(m1+e) storage and preprocessing time such that queries take O((n/√m)log2 n) time.We also describe a data structure for simplex intersection queries in a set of n convex fat constant-complexity polyhedra in R3. For any m with n 3, we can construct a structure that uses O(m1+e) storage and preprocessing time such that all polyhedra intersecting a query simplex can be reported in O((n/m1/3)log n+k) time, where k is the number of answers.

We propose a new model of realistic input: k-guardable objects. An object is k-guardable if its boundary can be seen by k guards. We show that k-guardable polygons generalize two previously identified classes of realistic input. Following this, we give two simple algorithms for triangulating k-guardable polygons. One algorithm requires the guards as input while the other does not. Both take linear time assuming that k is constant and both are easily implementable.

Chris Gray

Papers

Algorithms for Fat Objects: Decompositions and Applications

Ray shooting and intersection searching amidst fat convex polyhedra in 3-space

Cutting cycles of rods in space: hardness and approximation

Ray shooting and intersection searching amidst fat convex polyhedra in 3-space

Triangulating and Guarding Realistic Polygons.