Segment Visibility Counting Queries in Polygons

TL;DR

This paper introduces efficient data structures for counting objects visible within polygons, optimizing query times to polylogarithmic levels while minimizing space, applicable to points and segments inside polygons.

Contribution

It presents novel data structures for visibility counting queries in polygons, achieving fast query times with reduced space complexity for points and segments.

Findings

Achieves $O( ext{polylog } nm)$ query time for point visibility counting.

Develops a space-efficient data structure for segment queries involving points.

Handles segment objects with the same bounds efficiently.

Abstract

Let $P$ be a simple polygon with $n$ vertices, and let $A$ be a set of $m$ points or line segments inside $P$. We develop data structures that can efficiently count the number of objects from $A$ that are visible to a query point or a query segment. Our main aim is to obtain fast, $O(\mathop{\textrm{polylog}} nm$), query times, while using as little space as possible. In case the query is a single point, a simple visibility-polygon-based solution achieves $O(\log nm)$ query time using $O(nm^2)$ space. In case $A$ also contains only points, we present a smaller, $O(n + m^{2 + \varepsilon}\log n)$-space, data structure based on a hierarchical decomposition of the polygon. Building on these results, we tackle the case where the query is a line segment and $A$ contains only points. The main complication here is that the segment may intersect multiple regions of the polygon decomposition, and that a point may see multiple such pieces. Despite these issues, we show how to achieve $O(\log n\log nm)$ query time using only $O(nm^{2 + \varepsilon} + n^2)$ space. Finally, we show that we can even handle the case where the objects in $A$ are segments with the same bounds.