Alireza Zarei

Efficient computation of query point visibility in polygons with holes

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(n3 log(n)) to construct a data structure of size O(n3). It is then possible to report the visibility polygon of any query point q in time O((1+h′) log n+|V(q)|), in which n and h are the number of the vertices and holes of the polygon respectively, |V(q)| is the size of the visibility polygon of q, and h′ is an output and preprocessing sensitive parameter of at most min(h,|V(q)|). This is claimed to be the best query-time result on this problem so far.

Streaming Algorithms for Line Simplification

We study the following variant of the well-known line-simplification problem: we are getting a (possibly infinite) sequence of points p0,p1,p2,… in the plane defining a polygonal path, and as we receive the points, we wish to maintain a simplification of the path seen so far. We study this problem in a streaming setting, where we only have a limited amount of storage, so that we cannot store all the points. We analyze the competitive ratio of our algorithms, allowing resource augmentation: we let our algorithm maintain a simplification with 2k (internal) points and compare the error of our simplification to the error of the optimal simplification with k points. We obtain the algorithms with O(1) competitive ratio for three cases: convex paths, where the error is measured using the Hausdorff distance (or Fréchet distance), xy-monotone paths, where the error is measured using the Hausdorff distance (or Fréchet distance), and general paths, where the error is measured using the Fréchet distance. In the first case the algorithm needs O(k) additional storage, and in the latter two cases the algorithm needs O(k2) additional storage.

Streaming algorithms for line simplification

We study the following variant of the well-known line-simpli-ficationproblem: we are getting a possibly infinite sequence of points p0,p1,p2,... in the plane defining a polygonal path, and as wereceive the points we wish to maintain a simplification of the pathseen so far. We study this problem in a streaming setting, where weonly have a limited amount of storage so that we cannot store all thepoints. We analyze the competitive ratio of our algorithms, allowingresource augmentation: we let our algorithm maintain a simplificationwith 2k (internal) points, and compare the error of oursimplification to the error of the optimal simplification with k points. We obtain the algorithms with O(1) competitive ratio forthree cases: convex paths where the error is measured using theHausdorff distance (or Frechet distance), xy-monotone paths where the error is measured using theHausdorff distance (or Frechet distance), and general paths where the error is measured using theFrechet distance. In the first case the algorithm needs O(k) additionalstorage, and in the latter two cases the algorithm needs O(k2) additional storage.

A simple, faster method for kinetic proximity problems

For a set of n points in the plane, this paper presents simple kinetic data structures (KDSs) for solutions to some fundamental proximity problems, namely, the all nearest neighbors problem, the closest pair problem, and the Euclidean minimum spanning tree (EMST) problem. Also, the paper introduces KDSs for maintenance of two well-studied sparse proximity graphs, the Yao graph and the Semi-Yao graph.We use sparse graph representations, the Pie Delaunay graph and the Equilateral Delaunay graph, to provide new solutions for the proximity problems. Then we design KDSs that efficiently maintain these sparse graphs on a set of n moving points, where the trajectory of each point is assumed to be a polynomial function of constant maximum degree s. We use the kinetic Pie Delaunay graph and the kinetic Equilateral Delaunay graph to create KDSs for maintenance of the Yao graph, the Semi-Yao graph, all the nearest neighbors, the closest pair, and the EMST. Our KDSs use O ( n ) space and O ( n log ? n ) preprocessing time.We provide the first KDSs for maintenance of the Semi-Yao graph and the Yao graph. Our KDS processes O ( n 2 β 2 s + 2 ( n ) ) (resp. O ( n 3 β 2 s + 2 2 ( n ) log ? n ) ) events to maintain the Semi-Yao graph (resp. the Yao graph); each event can be processed in amortized time O ( log ? n ) . Here, β s ( n ) = λ s ( n ) / n is an extremely slow-growing function and λ s ( n ) is the maximum length of Davenport-Schinzel sequences of order s on n symbols.Our KDS for maintenance of all the nearest neighbors and the closest pair processes O ( n 2 β 2 s + 2 2 ( n ) log ? n ) events. For maintenance of the EMST, our KDS processes O ( n 3 β 2 s + 2 2 ( n ) log ? n ) events. For all three of these problems, each event can be handled in amortized time O ( log ? n ) .Our deterministic kinetic approach for maintenance of all the nearest neighbors improves by an O ( log 2 ? n ) factor the previous randomized kinetic algorithm by Agarwal, Kaplan, and Sharir. Furthermore, our KDS is simpler than their KDS, as we reduce the problem to one-dimensional range searching, as opposed to using two-dimensional range searching as in their KDS.For maintenance of the EMST, our KDS improves the previous KDS by Rahmati and Zarei by a near-linear factor in the number of events.

Kinetic Euclidean minimum spanning tree in the plane

This paper presents a kinetic data structure (KDS) for maintenance of the Euclidean minimum spanning tree (EMST) on a set of moving points in 2-dimensional space. For a set of n points moving in the plane we build a KDS of size O(n) in O(nlogn) preprocessing time by which the EMST is maintained efficiently during the motion. This is done by applying the required changes to the combinatorial structure of the EMST which is changed in discrete timestamps. We assume that the motion of the points, i.e. x and y coordinates of the points, are defined by algebraic functions of constant maximum degree. In terms of the KDS performance parameters, our KDS is responsive, local, and compact. The presented KDS is based on monitoring changes of the Delaunay triangulation of the points and edge-length changes of the edges of the current Delaunay triangulation.

Kinetic pie delaunay graph and its applications

We construct a new proximity graph, called the Pie Delaunay graph, on a set of n points which is a super graph of Yaograph and Euclidean minimum spanning tree (EMST). We efficiently maintain the PieDelaunaygraph where the points are moving in the plane. We use the kinetic PieDelaunaygraph to create a kinetic data structure (KDS) for maintenance of the Yaograph and the EMST on a set of n moving points in 2-dimensional space. Assuming x and y coordinates of the points are defined by algebraic functions of at most degree s, the structure uses O(n) space, O(nlogn) preprocessing time, and processes O(n2λ2s+2(n)βs+2(n)) events for the Yaograph and O(n2λ2s+2(n)) events for the EMST, each in O(log2n) time. Here, λs(n)=nβs(n) is the maximum length of Davenport-Schinzel sequences of order s on n symbols. Our KDS processes nearly cubic events for the EMST which improves the previous bound O(n4) by Rahmati etal. [1].

Weak visibility of two objects in planar polygonal scenes

Determining whether two segments s and t in a planar polygonal scene weakly see each other is a classical problem in computational geometry. In this problem we seek for a segment connecting two points of s and t without intersecting edges of the scene. In planar polygonal scenes, this problem is 3SUM-hard and its time complexity is Ω(n2) where n is the complexity of the scene. This problem can be defined in the same manner when s and t are any kind of objects in the plane. In this paper we consider this problem when s and t can be points, segments or convex polygons. We preprocess the scene so that for any given pair of query objects we can solve the problem efficiently. In our presented method, we preprocess the scene in O(n2+(Ɛ) time to build data structures of O(n2) total size by which the queries can be answered in O(n1+Ɛ) time. Our method is based on the extended visibility graph [1] and a range searching data structure presented by Chazelle et al. [2].

Computing polygonal path simplification under area measures

In this paper, we consider the restricted version of the well-known 2D line simplification problem under area measures and for restricted version. We first propose a unified definition for both of sum-area and difference-area measures that can be used on a general path of n vertices. The optimal simplification runs in O(n^3) under both of these measures. Under sum-area measure and for a realistic input path, we propose an approximation algorithm of On^2@e time complexity to find a simplification of the input path, where @e is the absolute error of this algorithm compared to the optimal solution. Furthermore, for difference-area measure, we present an algorithm that finds the optimal simplification in O(n^2) time. The best previous results work only on x-monotone paths while both of our algorithms work on general paths. To the best of our knowledge, the results presented here are the first sub-cubic simplification algorithms on these measures for general paths.

Touring disjoint polygons problem is NP-hard

In the Touring Polygons Problem (TPP) there is a start point s, a sequence of simple polygons \(\mathcal{P}=(P_1,\dots,P_k)\) and a target point t in the plane. The goal is to obtain a path of minimum possible length that starts from s, visits in order each of the polygons in \(\mathcal{P}\) and ends at t. This problem has a polynomial time algorithm when the polygons in \(\mathcal{P}\) are convex and is NP-hard in general case. But, it has been open whether the problem is NP-hard when the polygons are pairwise disjoint. In this paper, we prove that TPP is also NP-hard when the polygons are pairwise disjoint in any L p norm even if each polygon consists of at most two line segments. This result solves an open problem from STOC ’03 and complements recent approximation results.

Visibility testing and counting

Abstract For a set of n disjoint line segments S in R 2 , the visibility testing problem (VTP) is to test whether the query point p sees a query segment s ∈ S . For this configuration, the visibility counting problem (VCP) is to preprocess S such that the number of visible segments in S from any query point p can be computed quickly. In this paper, we solve VTP in expected logarithmic query time using quadratic preprocessing time and space. Moreover, we propose a ( 1 + δ ) -approximation algorithm for VCP using at most quadratic preprocessing time and space. The query time of this method is O ϵ ( 1 δ 2 n ) where O ϵ ( f ( n ) ) = O ( f ( n ) n ϵ ) and ϵ > 0 is an arbitrary constant number.