Shooting permanent rays among disjoint polygons in the plane

Abstract

Abstract. We present a data structure for ray shooting and insertion in the free space between disjoint polygonal obstacles with a total of n vertices in the plane, where each ray starts at the boundary of some obstacle. The portion of each query ray between the starting point and the first obstacle hit is inserted permanently as a new obstacle. Our data structure uses O(n log n) space and preprocessing time, and it supports m successive ray shooting and insertion queries in O((n + m) log 2 n + m log m) total time in the real RAM model of computation. We present two applications: (1) Our data structure supports efficient implementation of auto-partitions in the plane, that is, binary space partitions where each partition is done along the supporting line of an input segment. If n input line segments are fragmented into m pieces by an auto-partition, then it can now be implemented in O(n log 2 n + m log m) time. This improves the expected runtime of Patersen and Yao's classical randomized auto-partition algorithm for n disjoint line segments in the plane to O(n log 2 n). (2) If we are given disjoint polygonal obstacles with a total of n vertices in the plane, a permutation of the reflex vertices, and a half-line at each reflex vertex that partitions the reflex angle into two convex angles, then the convex partitioning algorithm draws a ray emanating from each reflex vertex in the prescribed order in the given direction until it hits another obstacle, a previous ray, or infinity. The previously best implementation (with a semidynamic ray shooting data structure) requires O(n 3/2−ε/2 ) time using O(n 1+ε ) space for any ε > 0. Our data structure improves the runtime to O(n log 2 n). Key words. ray shooting, tessellation, hierarchical decomposition AMS subject classifications. 68P05, 05C10DOI. 10.1137/1008043101. Introduction. Ray shooting data structures are a classical core component of computational geometry. They preprocess a set of objects in space such that one can efficiently find the first object hit by a query ray. A simple polygon with n vertices can be preprocessed in O(n) time to answer ray shooting queries in O(log n) time, using either a balanced geodesic triangulation [10] or a Steiner triangulation [21]. However, the free space between disjoint polygonal obstacles with a total of n vertices (e.g., n/2 disjoint line segments) cannot be handled as easily: the best ray shooting data structures can answer a query in O(n/ √ s) time using O(s) space and preprocessing, based on range searching data structures via parametric search. That is, an average query takes O( √ n) time using O(n) space (ignoring polylogarithmic factors). Geometric algorithms often rely on a ray shooting data structure, in which the result of

Computing Covers of Plane Forests

“…Ishaque et al [3] provide a ray shooting data structure that supports shooting rays from the boundary of obstacles, that are themselves inserted into the obstacles. Using their structure, a set of n pairwise disjoint polygonal obstacles can be preprocessed in O(n log n) time and space to support m permanent ray shootings in O((n + m) log 2 n + m log m) time.…”

Binary Plane Partitions for Disjoint Line Segments

“…When SubBSP(B, C, k) returns a BSP tree for cell C, we record the effect of the binary cuts in this data structure. We use the data structure of Ishaque et al [17] that supports the so-called ray shooting-and-insertion queries among disjoint polygonal obstacles in the plane. Each query is a point p on the line segment and a direction d p ; it reports the point q where the ray emitted by p in direction d p hits the first obstacle (ray shooting) and inserts the segment pq as a new obstacle (segment insertion).…”

Motorcycle graphs

“…Obviously, motorcycle graphs have strong relations to ray shooting problems. Ishaque et al [2009] present an O(n log 2 n + mlog m) algorithm for m repetitive ray shooting-and-insertion operations in the plane among a set of polygonal obstacles of total size n. As shown in Section 3.1, our algorithm computes a generalized version of motorcycle graphs: Arbitrary start times of the motorcycles are allowed, the motorcycles need not be known a priori, and we support rigid walls where motorcycles may crash against. In this sense, the general motorcycle graph problem is also a generalization of the ray shooting-and-insertion problem.…”