Embed Size (px)
Citation preview
EuroCG 2014, Ein-Gedi, Israel, March 3–5, 2014
Efficient Computation of Visibility Polygons
Francisc Bungiu∗ Michael Hemmer† John Hershberger‡ Kan Huang§ Alexander Kroller†
Abstract
Determining visibility in planar polygons and ar-rangements is an important subroutine for many al-gorithms in computational geometry. In this paper,we report on new implementations, and correspond-ing experimental evaluations, for two established andone novel algorithm for computing visibility polygons.These algorithms will be released to the public shortly,as a new package for the Computational GeometryAlgorithms Library (CGAL).
1 Introduction
Visibility is a basic concept in computational geome-try. For a polygon P ⊂ R2, we say that a point p ∈ Pis visible from q ∈ P if the line segment pq ⊆ P . Thepoints that are visible from q form the visibility re-gion V(q). Usually (if no degeneracies occur) V(q) is apolygon; hence it is often called the visibility polygon.If there are multiple vertices collinear with q, thenV(q) may take the form of a polygon with attachedone-dimensional antennae (see Figure 1).
Computing V(q), given a query point q, is a well-known problem with a number of established algo-rithms; see the book by Ghosh [9]. Besides beingof interest on its own, it also frequently appears as
∗Institute of Information Security at ETH Zurich, Switzer-land. [email protected]†Department of Computer Science, TU Braunschweig, Ger-
many. [email protected],[email protected]‡Mentor Graphics Corp., Wilsonville, OR, USA.
john [email protected]§Department of Applied Mathematics & Statistics, New
York, USA. [email protected]
Figure 1: Visibility polygon V(q) with antenna bc.
a subroutine in algorithms for other problems, mostprominently in the context of the Art Gallery Prob-lem [16]. In experimental work on this problem [15]we have identified visibility computations as having asubstantial impact on overall computation times, eventhough it is a low-order polynomial-time subroutine inan algorithm solving an NP-hard problem. Thereforeit is of enormous interest to have efficient implemen-tations of visibility polygon algorithms available.
CGAL, the Computational Geometry AlgorithmsLibrary [5], contains a large number of algorithmsand data structures, but unfortunately not for thecomputation of visibility polygons. We present im-plementations for three algorithms, which form thebasis for an upcoming new CGAL package for visi-bility. Two of these are efficient implementations forstandard O(n)- and O(n log n)-time algorithms fromthe literature. In addition, we describe a novel algo-rithm with preprocessing, called triangular expansion,based on an intriguingly simple idea using a triangu-lation of the underlying polygon. Even though thisalgorithm has a worst-case query runtime of O(n2), itis extremely fast in practice. In experiments we havefound it to outperform the other implementations byabout two orders of magnitude on large and practi-cally relevant inputs. The implementations follow theexact computation paradigm and handle all degener-ate cases, whether or not to include antennae in theoutput is configurable.
Our contribution is therefore threefold: We presenta new algorithm for computing visibility polygons.We report on an experimental evaluation, demon-strating the efficiency of the implementations, and re-vealing superior speed of the novel algorithm. Thepublication of the code is scheduled for CGAL re-lease 4.5 (October 2014).
2 Related Work
For a detailed coverage of visibility algorithms in twodimensions, see the book [9]. We denote by n thenumber of vertices of the input polygon P , by h thenumber of its holes, and by k the complexity of thevisibility region V(q) of the query point q.
The problem of computing V(q) was first addressedfor simple polygons in [7]. The first correct O(n) timealgorithm was given by Joe and Simpson [14]. For apolygon with holes, O(n log n) time algorithms wereproposed by Suri et al. [17] and Asano et al. [3]. An
This is an extended abstract of a presentation given at EuroCG 2014. It has been made public for the benefit of the community and should be considered a preprint rather than a formally reviewed paper. Thus, this work is expected to appear in a conference with formal proceedings and/or in a journal.
30th European Workshop on Computational Geometry, 2014
optimal O(n + h log h) algorithm was later given byHeffernan and Mitchell [11].
Ghodsi et al. [10] reduced the query time for simplepolygons to O(log n + k), at the expense of prepro-cessing requiring O(n3) time and space. In [4] Boseet al. showed that this time can also be achieved forpoints outside of P with an O(n3 log n) preprocessingtime. Aronov et al. [1] reduced the preprocessing timeand space to O(n2 log n) and O(n2) respectively withthe query time being increased to O(log2 n + k).
Allowing preprocessing for polygons with holes,Asano et al. [3] presented an algorithm with O(n)query time that requires O(n2) preprocessing timeand space. Vegter [18] gave an output sensitive algo-rithm whose query time is O(k log(n/k)), where pre-processing takes O(n2 log n) time and O(n2) space.Zarei and Ghodsi [19] gave another output sensitivealgorithm whose query time is O(1+min(h, k) log n+k) with O(n3 log n) preprocessing time and O(n3)space. Recent work by Inkulu and Kapoor [12] ex-tends the approaches of [1] and [19] by incorporatinga trade-off between preprocessing and query time.
Surprisingly, it seems that there are no exact andcomplete implementations of these algorithms at all.The only available software is GEOMPACK [13] butit does not use exact arithmetic and only implementsthe algorithm for simple polygons of Joe and Simp-son [14].
3 Implemented Algorithms
The following algorithms are implemented in C++, andare part of an upcoming CGAL package for visibility.
3.1 Algorithm of Joe and Simpson [14]
The visibility polygon algorithm by Joe and Simp-son [14] runs in O(n) time and space. It performs asequential scan of the boundary of P , a simple poly-gon (without holes), and uses a stack s of boundarypoints s0, s1, . . . , st such that at any time, the stackrepresents the visibility polygon with respect to thealready scanned part of P ’s boundary.
When the current edge vivi+1 is in process, threepossible operations can be performed: new bound-ary points are added to the stack, obsolete boundarypoints are deleted from the stack, or subsequent edgeson the polygon’s boundary are scanned until a certaincondition is met. The later is performed when theedge enters a so-called “hidden-window,” where thepoints are not visible from the viewpoint q.
The implementation uses states to process theboundary of the polygon P and manipulate the stacks such that, in the end, it contains the vertices defin-ing the visibility polygon’s boundary. The main statehandles the case when the current edge vivi+1 takes aleft turn and vi+1 is pushed on the stack. The other
states are entered when vivi+1 turns behind a previ-ous edge. Then the algorithm scans the subsequentedges until the boundary reappears from behind thelast visible edge. In order to deal with cases in whichthe polygon winds more than 360◦, a winding counteris used during this edge processing.
3.2 Algorithm of Asano [2]
The algorithm by Asano [2] runs in O(n log n) timeand O(n) space. It follows the classical plane sweepparadigm with the difference that the event line L is aray that originates from and rotates around the querypoint q. Thus, initially all vertices of the input poly-gon (event points) are sorted according to their polarangles with respect to the query point q. Segmentsthat intersect the ray L are stored in a balanced bi-nary tree T based on their order of intersections withL. As the sweep proceeds, T is updated and a newvertex of V (q) is generated each time the smallest el-ement (segment closest to q) in T changes.
The algorithm can be implemented using basic al-gorithms and data structures such as std::sort (forordering event points) and std::map (ordering seg-ments on the ray). However, it is crucial that theunderlying comparison operations are efficient. Weomit details of the angular comparison for verticesand sketch the ordering along L.
q
s2
a2
b2
s1
b1
a1
For an efficient compari-son of two segments s1 ands2 along the ray L, it isimportant to avoid explicit(and expensive) construc-tion of intersection pointswith L. In fact, L can staycompletely abstract. As-suming that s1 and s2 haveno common endpoint, theorder can be determined using at most five orientationpredicates. Consider the figure to the right: the seg-ment s1 is further away since q, a2 and b2 are on thesame side of s1 (three calls). In case this is not con-clusive, two additional calls for q and a1 with respectto s2 are sufficient.
3.3 New Algorithm: Triangular Expansion
We introduce a new algorithm that, to the best ofour knowledge, has not been discussed in the litera-ture. Its worst case complexity is O(n2) but it is veryefficient in practice as it is, in some sense, output sen-sitive.
In an initial preprocessing phase the polygon is tri-angulated. For polygons with holes this is possible inO(n log n) time [8] and in O(n) time for simple poly-gons [6]. However, for the implementation we usedCGAL’s constrained Delaunay triangulation which re-
EuroCG 2014, Ein-Gedi, Israel, March 3–5, 2014
q
r
`
a
b
v
`′
e∆
P
e`
er
Figure 2: Triangular expansion algorithm — recursionentering triangle ∆ through edge e.
quires O(n2) time in the worst case but behaves wellin practice.
Given a query point q, we locate the triangle con-taining q by a simple walk. Obviously q sees the entiretriangle and we can report all edges of this trianglethat belong to ∂P . For every other edge we start a re-cursive procedure that expands the view of q throughthat edge into the next triangle. Initially the view isrestricted by the two endpoints of the edge. However,while the recursion proceeds the view can be furtherrestricted. This is depicted in Figure 2: The recur-sion enters triangle ∆ through edge e with endpointsa and b. The view of q is restricted by the two reflexvertices l and r, where a ≤ r < ` ≤ b with respectto angular order around q. The only new vertex is vand its position with respect to ` and r is computedwith two orientation tests. In the example of Figure 2the vertex v is between ` and r, thus we have to con-sider both edges e` and er: e` is a boundary edge andwe can report edge ``′ and `′v as part of ∂V(q); er isnot a boundary edge, which implies that the recursioncontinues with v being the vertex that now restrictsthe left side of the view.
The recursion may split into two calls if e` and erare both not part of the boundary. As there are n ver-tices, this can happen O(n) times; each call may reachO(n) triangles, which suggests a worst-case runtime ofO(n2). However, a true split into two visibility conesthat may reach the same triangle independently canhappen only at a hole of P . Thus, at worst the run-time is O(nh), where h is the number of holes. Thisimplies that the runtime is linear for simple polygons.
Figure 3 sketches the worst case scenario, whichwe also used in our experiments (Section 4). Thek = Θ(n) holes in the middle of the long room splitthe view of v0 into k + 1 cones, each of which passesthrough k = Θ(n) Delaunay edges. Thus, in this sce-nario the algorithm has complexity Θ(n2).
However, ignoring the preprocessing, the algorithmoften runs in sublinear time, since it processes onlythose triangles that are actually seen. This can be
v0
bk/2c
dk/2e
k
Figure 3: Θ(n2) worst case for triangular expansion.
a very small subset of the actual polygon. Unfor-tunately, this is not strictly output sensitive, since avisibility cone may traverse a triangle even though thetriangle does not contribute to the boundary of V(q).
Since the triangulation has linear size and since atany time there are at most O(n) recursive calls on thestack, the algorithm requires O(n) space.
4 Experiments
The experiments were run on an Intel(R) Core(TM)i7-3740QM CPU at 2.70GHz with 6 MB cache and 16GB main memory running a 64-bit Linux 3.2.0 ker-nel. All algorithms are developed against the latestrelease (i.e., 4.3) of CGAL. None of the algorithmsuses parallelization. We tested three different scenar-ios: Norway (Figure 4) a simple polygon with 20981vertices, cathedral (Figure 5) a general polygon with1209 vertices, and the already mentioned worst casescenario (Figure 3) for the triangular expansion algo-rithm.
In tables TQueries indicates the total time to com-pute the visibility polygons for all vertices, while Ttotal
also includes the time for preprocessing. Avg indi-cates the average time required to compute the visi-bility area for one vertex including preprocessing. Al-gorithms are indicated as follows: (S) the algorithm ofJoe and Simpson [14] for simple polygons; (R) the al-gorithm of Asano [2] performing the rotational sweeparound the query point; (T) our new triangular ex-pansion algorithm.
Since runtimes did not differ significantly we do notreport on similar benchmarks with query points onedges and in the interior polygon.
For the real world scenarios, cathedral and Norway,we can observe that the average runtime of the trian-gular expansion algorithm is two orders of magnitudefaster than the rotational sweep algorithm. It is morethan one order of magnitude faster than the specialalgorithm for simple polygons on the Norway data set.However, for the worst case scenario, Figure 6 showsthat eventually the sweep algorithm becomes fasterwith increasing input complexity.
30th European Workshop on Computational Geometry, 2014
Alg. TPrePro TQueries TTotal AvgS — 117.43 s 117.43 s 5.60 msR — 1193.29 s 1193.29 s 56.87 msT 0.21 s 3.66 s 3.88 s 0.18 ms
Figure 4: Norway example.
Alg. TPrePro TQueries TTotal AvgR — 1.35 s 1.35 s 1.112 msT 0.004 s 0.04 s 0.04 s 0.004 ms
Figure 5: Cathedral example.
0
0.05
0.1
0.15
0.2
0.25
0 5000 10000 15000 20000 25000 30000 35000
aver
age
quer
y t
ime
in s
ec
number of vertices
RT
Figure 6: Worst case scenario.
Acknowledgements. This work was supported byGoogle Summer of Code and the Deutsche For-schungsgemeinschaft (DFG), contract KR 3133/1-1(Kunst!).
References
[1] B. Aronov, L. J. Guibas, M. Teichmann, andL. Zhang. Visibility queries and maintenance in
simple polygons. Discrete & Comp. Geometry,27(4):461–483, 2002.
[2] T. Asano. An efficient algorithm for finding the visi-bility polygon for a polygonal region with holes. IE-ICE Transactions, 68(9):557–559, 1985.
[3] T. Asano, T. Asano, L. Guibas, J. Hershberger, andH. Imai. Visibility of disjoint polygons. Algorithmica,1(1-4):49–63, 1986.
[4] P. Bose, A. Lubiw, and J. I. Munro. Efficient visibilityqueries in simple polygons. Computational Geometry,23(3):313–335, 2002.
[5] Cgal, Computational Geometry Algorithms Library.http://www.cgal.org.
[6] B. Chazelle. Triangulating a simple polygon in lineartime. Discrete & Comp. Geom., 6(1):485–524, 1991.
[7] L. S. Davis and M. L. Benedikt. Computational mod-els of space: Isovists and isovist fields. ComputerGraphics and Image Processing, 11(1):49–72, 1979.
[8] M. de Berg, O. Cheong, M. van Kreveld, andM. Overmars. Computational Geometry: Algorithmsand Applications. Springer-Verlag, 3rd edition, 2008.
[9] S. K. Ghosh. Visibility algorithms in the plane. Cam-bridge University Press, 2007.
[10] L. J. Guibas, R. Motwani, and P. Raghavan. Therobot localization problem. SIAM Journal on Com-puting, 26(4):1120–1138, 1997.
[11] P. J. Heffernan and J. S. Mitchell. An optimal al-gorithm for computing visibility in the plane. SIAMJournal on Computing, 24(1):184–201, 1995.
[12] R. Inkulu and S. Kapoor. Visibility queries in a polyg-onal region. Comp. Geometry, 42(9):852–864, 2009.
[13] B. Joe. Geompack users’ guide. Department of Com-puting Science, University of Alberta, Edmonton, Al-berta, Canada T6G 2H1, 1993.
[14] B. Joe and R. Simpson. Corrections to Lee’s visibil-ity polygon algorithm. BIT Numerical Mathematics,27(4):458–473, 1987.
[15] A. Kroller, T. Baumgartner, S. P. Fekete, andC. Schmidt. Exact solutions and bounds for gen-eral art gallery problems. Journal of ExperimentalAlgorithmics, 17(1), 2012.
[16] J. O’Rourke. Art Gallery Theorems and Algorithms.International Series of Monographs on Computer Sci-ence. Oxford University Press, New York, NY, 1987.
[17] S. Suri and J. O’Rourke. Worst-case optimal algo-rithms for constructing visibility polygons with holes.In Proceedings of the second annual symposium onComputational geometry, pages 14–23. ACM, 1986.
[18] G. Vegter. The visibility diagram: a data struc-ture for visibility problems and motion planning. InSWAT 90, pages 97–110. Springer, 1990.
[19] A. Zarei and M. Ghodsi. Efficient computation ofquery point visibility in polygons with holes. InProceedings of the twenty-first annual symposium onComputational geometry, pages 314–320. ACM, 2005.
