Visibility queries in a polygonal region

Computational Geometry, 2002

We present a method of decomposing a simple polygon that allows the preprocessing of the polygon to efficiently answer visibility queries of various forms in an output sensitive manner. Using O(n 3 log n) preprocessing time and O(n 3) space, we can, given a query point q inside or outside an n vertex polygon, recover the visibility polygon of q in O(log n + k) time, where k is the size of the visibility polygon, and recover the number of vertices visible from q in O(log n) time. The key notion behind the decomposition is the succinct representation of visibility regions, and tight bounds on the number of such regions. These techniques are extended to handle other types of queries, such as visibility of fixed points other than the polygon vertices, and for visibility from a line segment rather than a point. Some of these results have been obtained independently by Guibas, Motwani and Raghavan [18].

2009

Computing the visibility polygon, VP, of a point in a polygonal scene, is a classical problem that has been studied extensively. In this paper, we consider the problem of computing VP for any query point efficiently, with some additional preprocessing phase. The scene consists of a set of obstacles, of total complexity O (n). We show for a query point q, VP (q) can be computed in logarithmic time using O (n 4) space and O (n 4 logn) preprocessing time.

2005

Abstract In this paper, we consider the problem of computing the visibility of a query point inside polygons with holes. The goal is to perform this computation efficiently per query with more cost in the preprocessing phase. Our algorithm is based on solutions in [13] and [2] proposed for simple polygons. In our solution, the preprocessing is done in time O (n 3 log (n)) to construct a data structure of size O (n 3).

2008

In this paper, we consider the problem of computing the visibility of a query point inside polygons with holes. The goal is to perform this computation efficiently per query considering the cost of the preprocessing phase. Our algorithm is based on solutions in [ALP Bose, JI Munro, Efficient visibility queries in simple polygons, Computational Geometry: Theory and Applications 23 (3)(2002) 313–335] and [MTB Aronov, L. Guibas, L.

Proceedings of the twentieth annual symposium on Computational geometry - SCG '04, 2004

We study the problem of computing the visibility graph defined by a set P of n points inside a polygon Q: two points p, q ∈ P are joined by an edge if the segment pq ⊂ Q. Efficient output-sensitive algorithms are known for the case in which P is the set of all vertices of Q. We examine the general case in which P is an arbitrary set of points, interior or on the boundary of Q and study a variety of algorithmic questions. We give an output-sensitive algorithm, which is nearly optimal, when Q is a simple polygon. We introduce a notion of "fat" or "robust" visibility, and give a nearly optimal algorithm for computing visibility graphs according to it, in polygons Q that may have holes. Other results include an algorithm to detect if there are any visible pairs among P, and algorithms for output-sensitive computation of visibility graphs with distance restrictions, invisibility graphs, and rectangle visibility graphs.

2002

In this paper we consider the simple polygon visibility problem: Given a simple polygon P with N vertices and a point t in the interior of the polygon, find all the boundary points of P that are visible from 2. We present an O(log N log log N) time algorithm that solves the simple polygon visibility problem on a f i x f i RMESH. Previously, the best known algorithm for the problem on a f i x f l RMESH takes O(logz N) time.

Abstract In this paper, we consider the problem of computing the weak visibility (WV) of a query line segment inside a simple polygon. Our algorithm first preprocesses the polygon and creates data structures from which any WV query is answered efficiently in an output sensitive manner. In our solution, the preprocessing is performed in time O (n3 log n) and the size of the constructed data structure is O (n3).

SIAM Journal on Computing, 2000

This paper describes an output-sensitive scheme to construct the visibility graph of a simple polygon with m obstacles and n vertices in optimal O(|E| + T + m log n) time where |E| is the size of the visibility graph and T is the time required to triangulate the simple polygon with obstacles. We use a partition of the space into regions called corridors which eases the efforts of the construction. Our algorithms are simple and the data structures used are only linked lists.

Computational Geometry, 2014

Please cite this article in press as: L. Barba et al., Computing a visibility polygon using few variables, Computational Geometry (2014), http://dx.Abstract 4 We present several algorithms for computing the visibility polygon of a simple polygon 5 P of n vertices (out of which r are reflex) from a viewpoint inside P, when P resides in 6 read-only memory and only few working variables can be used. The first algorithm uses a 7 constant number of variables, and outputs the vertices of the visibility polygon in O(nr) time, 8 wherer denotes the number of reflex vertices of P that are part of the output. Whenever 9 we are allowed to use O(s) variables, the running time decreases to O( nr 2 s + n log 2 r) (or 10 O( nr 2 s + n log r) randomized expected time), where s ∈ O(log r). This is the first algorithm in 11 which an exponential space-time trade-off for a geometric problem is obtained. 12 1 Introduction 13 The visibility polygon of a simple polygon P from a viewpoint q is the set of all points of P that 14 can be seen from q, where two points p and q can see each other whenever the segment pq is 15 contained in P. The visibility polygon is a fundamental concept in computational geometry and 16 one of the first problems studied in planar visibility. The first correct and optimal algorithm for 17 computing the visibility polygon from a point was found by Joe and Simpson [20]. It computes 18 the visibility polygon from a point in linear time and space. We refer the reader to the survey of 19 O'Rourke [23] and the book of Gosh [17] for an extensive discussion of such problems. 20 In this paper we look for an algorithm that computes the visibility polygon of a given point 21 and uses few variables. This kind of algorithm not only provides an interesting trade-off between 22 running time and memory needed, but is also useful in portable devices where important hardware 23 constraints are present (such as the ones found in digital cameras or mobile phones). In addition, 24 this model has direct applications in concurrent environments where several devices with limited 25 memory resources perform some computation on a large centralized input. Since several devices 26 may access the input at the same time, allowing writing to the input memory can result in 27 compromising its integrity. 28 A significant amount of research has focused on the design of algorithms that use few variables, 29 some of them even dating from the 80s [21]. Although many models exist, most of the research 30 considers that the input is in some kind of read-only data structure. In addition to the input 31 values, we are allowed to use few additional variables (typically a variable holds a logarithmic 32 number of bits). 33 * A preliminary version of this paper appeared in the proceedings of the 22nd International Symposium on Algorithms and Computation (ISAAC 2011) [10].

International Journal of Computational Geometry & Applications, 2020

We devise the following dynamic algorithms for both maintaining as well as querying for the visibility and weak visibility polygons amid vertex insertions and deletions to the simple polygon. A fully-dynamic algorithm for maintaining the visibility polygon of a fixed point located interior to the simple polygon amid vertex insertions and deletions to the simple polygon. The time complexity to update the visibility polygon of a point [Formula: see text] due to the insertion (resp. deletion) of vertex [Formula: see text] to (resp. from) the current simple polygon is expressed in terms of the number of combinatorial changes needed to the visibility polygon of [Formula: see text] due to the insertion (resp. deletion) of [Formula: see text]. An output-sensitive query algorithm to answer the visibility polygon query corresponding to any point [Formula: see text] in [Formula: see text] amid vertex insertions and deletions to the simple polygon. If [Formula: see text] is not exterior to the...