VoR-Tree: R-trees with Voronoi Diagrams for Efficient Processing of Spatial Nearest Neighbor Queries∗

† Mehdi Sharifzadeh Cyrus Shahabi Google University of Southern California [email protected] [email protected]

ABSTRACT A very important class of spatial queries consists of nearest- An important class of queries, especially in the geospatial neighbor (NN) query and its variations. Many studies in domain, is the class of nearest neighbor (NN) queries. These the past decade utilize R-trees as their underlying index queries search for data objects that minimize a distance- structures to address NN queries efficiently. The general ap- based function with reference to one or more query objects. proach is to use R-tree in two phases. First, R-tree’s hierar- Examples are k Nearest Neighbor (kNN) [13, 5, 7], Reverse chical structure is used to quickly arrive to the neighborhood k Nearest Neighbor (RkNN) [8, 15, 16], k Aggregate Nearest of the result set. Second, the R-tree nodes intersecting with Neighbor (kANN) [12] and skyline queries [1, 11, 14]. The the local neighborhood (Search Region) of an initial answer applications of NN queries are numerous in geospatial deci- are investigated to find all the members of the result set. sion making, location-based services, and sensor networks. While R-trees are very efficient for the first phase, they usu- The introduction of R-trees [3] (and their extensions) for ally result in the unnecessary investigation of many nodes indexing multi-dimensional data marked a new era in de- that none or only a small subset of their including points veloping novel R-tree-based algorithms for various forms belongs to the actual result set. of Nearest Neighbor (NN) queries. These algorithms uti- On the other hand, several recent studies showed that the lize the simple rectangular grouping principle used by R- Voronoi diagrams are extremely efficient in exploring an NN tree that represents close data points with their Minimum search region, while due to lack of an efficient access method, Bounding Rectangle (MBR). They generally use R-tree in their arrival to this region is slow. In this paper, we propose two phases. In the first phase, starting from the root node, a new index structure, termed VoR-Tree that incorporates they iteratively search for an initial result a. To find a, they Voronoi diagrams into R-tree, benefiting from the best of visit/extract the nodes that minimize a function of the dis- both worlds. The coarse granule rectangle nodes of R-tree tance(s) between the query points(s) and the MBR of each enable us to get to the search region in logarithmic time node. Meanwhile, they use heuristics to prune the nodes while the fine granule polygons of Voronoi diagram allow that cannot possibly contain the answer. During this phase, us to efficiently tile or cover the region and find the result. R-tree’s hierarchical structure enables these algorithms to Utilizing VoR-Tree, we propose efficient algorithms for vari- find the initial result a in logarithmic time. ous Nearest Neighbor queries, and show that our algorithms Next, the local neighborhood of a, Search Region (SR) of a have better I/O complexity than their best competitors. for an NN query [5], must be explored further for any possi- bly better result. The best approach is to visit/examine only 1. INTRODUCTION the points in SR of a in the direction that most likely con- tains a better result (e.g., from a towards the query point q ∗This research has been funded in part by NSF grants IIS- 0238560 (PECASE), IIS-0534761, and CNS-0831505 (Cy- for a better NN). However, with R-tree-based algorithms the berTrust), the NSF Center for Embedded Networked Sens- only way to retrieve a point in this neighborhood is through ing (CCR-0120778) and in part from the METRANS Trans- R-tree’s leaf nodes. Hence, in the second phase, a blind portation Center, under grants from USDOT and Caltrans. traversal must repeatedly go up the tree to visit higher-level Any opinions, findings, and conclusions or recommendations nodes and then come down the tree to visit their descendants expressed in this material are those of the author(s) and and the leaves to explore this neighborhood. This traversal do not necessarily reflect the views of the National Science Foundation. is combined with pruning those nodes that are not intersect- †The work was completed when the author was studying ing with SR of a and hence contain no point of SR. Here, PhD at USC’s InfoLab. different algorithms use alternative thresholds and heuris- tics to decide which R-tree nodes should be investigated further and which ones should be pruned. While the em- Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are ployed heuristics are always safe to cover the entire SR and not made or distributed for profit or commercial advantage and that copies hence guarantee the completeness of result, they are highly bear this notice and the full citation on the first page. To copy otherwise, to conservative for two reasons: 1) They use the distance to republish, to post on servers or to redistribute to lists, requires prior specific the coarse granule MBR of points in a node N as a lower- permission and/or a fee. Articles from this volume were presented at The bound for the actual distances to the points in N. This 36th International Conference on Very Large Data Bases, September 13-17, lower-bound metric is not tight enough for many queries 2010, Singapore. Proceedings of the VLDB Endowment, Vol. 3, No. 1 (e.g., RkNN) 2) With some queries (e.g., kANN), the irreg- Copyright 2010 VLDB Endowment 2150-8097/10/09... $ 10.00. ular shape of SR makes it difficult to identify intersecting nodes using a heuristic. As a result, the algorithm exam- ines all the nodes intersecting with a larger superset of SR. V(p) That is, the conservative heuristics prevent the algorithm p to prune many nodes/points that are not even close to the V. vertex of p actual result. A data structure that is extremely efficient in exploring V. neighbor of p V. edge of p a local neighborhood in a geometric space is Voronoi dia- (a) (b) gram [10]. Given a set of points, a general Voronoi diagram Figure 1: a) Voronoi diagram, b) Delaunay graph uniquely partitions the space into disjoint regions. The re- performance of our algorithms. gion (cell) corresponding to a point o covers the points in For kNN queries, our incremental algorithm uses an im- space that are closer to o than to any other point. The dual portant property of Voronoi diagrams to retrieve/examine representation, Delaunay graph, connects any two points only the points neighboring the (k−1)-th closest points to whose corresponding cells share a border (and hence are the query point. Our experiments verify that our algorithm close in a certain direction). Thus, to explore the neighbor- outperforms BFS [5] in terms of I/O cost (number of ac- hood of a point a it suffices to start from the Voronoi cell cessed disk pages; up to 18% improvement). For RkNN containing a and repeatedly traverse unvisited neighboring queries, we show that unlike TPL [16], our algorithm is Voronoi cells (as if we tile the space using visited cells). The scalable with respect to k and outperforms TPL in terms fine granule polygons of Voronoi diagram allows an efficient of I/O cost by at least 3 orders of magnitude. For kANN coverage of any complex-shaped neighborhood. This makes queries, our algorithm through a diffusive exploration of the Voronoi diagrams efficient structures to explore the search irregular-shaped SR prunes many nodes/points examined by region during processing NN queries. Moreover, the search the MBM algorithm [12]. It accesses a small fraction of disk region of many NN queries can be redefined as a limited pages accessed by MBM (50% decrease in I/O). neighborhood through the edges of Delaunay graphs. Con- sequently, an algorithm can traverse any complex-shaped SR 2. BACKGROUND without requiring the MBR-based heuristics of R-tree (e.g, The Voronoi diagram of a given set P = {p1, . . . , pn} of d d in Section 4 we prove that the reverse kth NN of a point p is n points in R partitions the space of R into n regions. d at most k edges far from p in the Delaunay graph of data). Each region includes all points in R with a common closest In this paper, we propose to incorporate Voronoi dia- point in the given set P according to a distance metric D(., .) grams into the R-tree index structure. The resulting data [10]. That is, the region corresponding to the point p ∈ P d structure, termed VoR-Tree, is a regular R-tree enriched contains all the points q ∈ R for which we have by the Voronoi cells and pointers to Voronoi neighbors of 0 0 0 each point stored together with the point’s geometry in its ∀p ∈ P, p 6= p, D(q, p) ≤ D(q, p ) (1) data record. VoR-Tree uses more disk space than a regu- The equality holds for the points on the borders of p’s and lar R-Tree but instead it highly facilitates NN query pro- p0’s regions. Figure 1a shows the ordinary Voronoi diagram cessing. VoR-Tree is different from an access method for of nine points in 2 where the distance metric is Euclidean. Voronoi diagrams such as Voronoi history graph [4], os-tree R We refer to the region V (p) containing the point p as its [9], and D-tree [17]. Instead, VoR-Tree benefits from the Voronoi cell. With Euclidean distance in 2, V (p) is a con- best of two worlds: coarse granule hierarchical grouping of R vex polygon. Each edge of this polygon is a segment of the R-trees and fine granule exploration capability of Voronoi perpendicular bisector of the line segment connecting p to diagrams. Unlike similar approaches that index the Voronoi another point of the set P . We call each of these edges a cells [18, 6] or their approximations in higher dimensions Voronoi edge and each of its end-points (vertices of the poly- [7], VoR-Tree indexes the actual data objects. Hence, all R- gon) a Voronoi vertex of the point p. For each Voronoi edge tree-based query processing algorithms are still feasible with of the point p, we refer to the corresponding point in the set VoR-Trees. However, adding the connectivity provided by P as a Voronoi neighbor of p. We use VN(p) to denote the the Voronoi diagrams enables us to propose I/O-efficient al- set of all Voronoi neighbors of p. We also refer to point p gorithms for different NN queries. Our algorithms use the as the generator of Voronoi cell V (p). Finally, the set given information provided in VoR-tree to find the query result by by VD(P ) = {V (p ), ..., V (p )} is called the Voronoi dia- performing the least number of I/O operations. That is, at 1 n gram generated by P with respect to the distance function each step they examine only the points inside the current D(., .). Throughout this paper, we use Euclidean distance search region. This processing strategy is used by R-tree- function in 2. Also, we simply use Voronoi diagram to based algorithms for I/O-optimal processing of NN queries R denote ordinary Voronoi diagram of a set of points in 2. [5]. While both Voronoi diagrams and R-trees are defined R Now consider an undirected graph DG(P ) = G(V,E) with for the space of d which makes VoR-Tree applicable for R the set of vertices V = P . For each two points p and p0 in V , higher dimensions, we focus on 2-d points that are widely there is an edge connecting p and p0 in G iff p0 is a Voronoi available/queried in geospatial applications. neighbor of p in the Voronoi diagram of P . The graph G is We study three types of NN query and their state-of-the- called the Delaunay graph of points in P . This graph is a art R-tree-based algorithms: 1) kNN and Best-First Search connected planar graph. Figure 1b illustrates the Delaunay (BFS) [5], 2) RkNN and TPL [16], and 3) kANN and MBM graph corresponding to the points of Figure 1a. In Section [12] (see Appendix F for more queries). For each query, 4.2, we traverse the Delaunay graph of the database points we propose our VoR-Tree-based algorithm, the proof of its to find the set of reverse nearest neighbors of a point. correctness and its complexities. Finally, through extensive We review important properties of Voronoi diagrams [10]. experiments using three real-world datasest, we evaluate the Property V-1: The Voronoi diagram of a set P of points, VD(P ), is unique. 4 5 13 Property V-2: Given the Voronoi diagram of P , the near- 7 est point of P to point p ∈ P is among the Voronoi neighbors of p. That is, the closest point to p is one of generator points 12 whose Voronoi cells share a Voronoi edge with V (p). In Sec- 3 6 tion 4.1, we utilize a generalization of this property in our 14 8 kNN query processing algorithm. 2 2 6 4 3 Property V-3: The average number of vertices per Voronoi 2 1 5 cells of the Voronoi diagram of a set of points in R does not 1 exceed six. That is, the average number of Voronoi neigh- 7 bors of each point of P is at most six. We use this property to derive the complexity of our query processing algorithms. (a) R 3. VOR-TREE N In this section, we show how we use an R-tree (see Ap- 6 N7 pendix A for definition of R-Tree) to index the Voronoi dia- N1 N2 N3 N4 N5 … p p p … … … gram of a set of points together with the actual points. We 4 5 6 refer to the resulting index structure as VoR-Tree, an R-tree VN(p )={ p , p , p , p , p } of point data augmented with the points’ Voronoi diagram. 6 5 2 3 12 4 V(p6)={...} Suppose that we have stored all the data points of set VN(p )={ p , p , p , p , p } P in an R-tree. For now, assume that we have pre-built 5 1 2 6 4 7 V(p5)={…}

VD(P ), the Voronoi diagram of P . Each leaf node of R- VN(p4)={ p5, p6, p12, p14, p8, p7 } V(p )={a, b, c, d, e, f} tree stores a subset of data points of P . The leaves also (b) 4 include the data records containing extra information about Figure 2: a) Voronoi diagram and b) the VoR-Tree the corresponding points. In the record of the point p, we of the points shown in Figure 11 store the pointer to the location of each Voronoi neighbor of p (i.e., VN(p)) and also the vertices of the Voronoi cell of p (i.e., V (p)). The above instance of R-tree built using points D(q, p) for all points p ∈ P \{p1, . . . , pk} [13]. We use in P is the VoR-Tree of P . kNN(q)={p1, . . . , pk} to denote the ordered result set; pi is Figure 2a shows the Voronoi diagram of the same points the i-th NN of q. shown in Figure 11. To bound the Voronoi cells with infinite The I/O-optimal algorithm for finding kNNs using an R-tree is the Best-First Search (BFS) [5]. BFS traverses edges (e.g., V (p3)), we clip them using a large rectangle bounding the points in P (the dotted rectangle). Figure 2b the nodes of R-tree from the root down to the leaves. It illustrates the VoR-Tree of the points of P . For simplicity, maintains the visited nodes N in a minheap sorted by their mindist(N, q). Consider the R-tree of Figure 2a (VoR-Tree it shows only the contents of leaf node N2 including points without Voronoi records) and query point q. BFS first visits p4, p5, and p6, the generators of grey Voronoi cells depicted in Figure 2a. The record associated with each point p in the root R and adds its entries together with their mindist() values to the heap H (H={(N , 0),(N , 2)}). Then, at each N2 includes both Voronoi neighbors and vertices of p in a 6 7 common sequential order. We refer to this record as Voronoi step BFS accesses the node at the top of H and adds all its record of p. Each Voronoi neighbor p0 of p maintained in entries into H. Extracting N6, we get H={(N7, 2),(N3, 3), this record is actually a pointer to the disk page storing p0’s (N2, 7),(N1, 17)}. Then, we extract N7 to get H={(N5, 2), information (including its Voronoi record). In Section 4, we (N3, 3),(N2, 7),(N1, 17),(N4, 26)}. Next, we extract the point use these pointers to navigate within the Voronoi diagram. entries of N5 where we find p14 as the first potential NN In sum, VoR-Tree of P is an R-tree on P blended with of q. Now, as mindist() of the first entry of H is less Voronoi diagram VD(P ) and Delaunay graph DG(P ) of P . than the distance of the closest point to q we have found Trivially, Voronoi neighbors and Voronoi cells of the same so far (bestdist=D(p14, q)=5), we must visit N3 to explore point can be computed from each other. However, VoR- any of its potentially better points. Extracting N3 we real- Tree stores both of these sets to avoid the computation cost ize that its closest point to q is p8 with D(p8, q)=8>bestdist when both are required. For applications focusing on specific and hence we return p14 as the nearest neighbor (NN) of q queries, only the set required by the corresponding query (NN(q)=p14). As an incremental algorithm, we can con- processing algorithm can be stored. tinue the iterations of BFS to return all k nearest neighbors of q in their ascending order to q. Here, bestdist is the dis- 4. QUERY PROCESSING tance of the k-th closest point found so far to q . In this section, we discuss our algorithms to process dif- For a general query Q on set P , we define the search region 2 ferent nearest neighbor queries using VoR-Trees. For each (SR) of a point p ∈ P as the portion of R that may contain query, we first review its state-of-the-art algorithm. Then, a result better than p in P . BFS is considered I/O-optimal we present our algorithm showing how maintaining Voronoi as at each iteration it visits only the nodes intersecting the records in VoR-Tree boosts the query processing capabilities SR of its best candidate result p (i.e., the circle centered at of the corresponding R-tree. q and with radius equal to D(q, p)). However, as the above example shows nodes such as N3 while intersecting SR of 4.1 k Nearest Neighbor Query (kNN) p14 might have no point closer than p14 to q. We show how Given a query point q, k Nearest Neighbor (kNN) query one can utilize Voronoi records of VoR-Tree to avoid visiting finds the k closest data points to q. Given the data set these nodes. P , it finds k points pi ∈ P for which we have D(q, pi) ≤ First, we show our VR-1NN algorithm for processing 1NN queries (see Figure 13 for the pseudo-code). VR-1NN works similar to BFS. The only difference is that once VR-1NN 2 1 3 finds a candidate point p, it accesses the Voronoi record of 2 2 1 p. Then, it checks whether the Voronoi cell of p contains 2 the query point q (Line 8 of Figure 13). If the answer is 3 4 1 positive, it returns p (and exits) as p is the closest point to 1 q according to the definition of a Voronoi cell. Incorporat- ing this containment check in VR-1NN, avoids visiting (i.e., (a) (b) prunes) node N3 in the above example as V (p14) contains q. Figure 3: a) Improving over BFS, b) p ∈ R2NN(q) To extend VR-1NN for general kNN processing, we utilize of their k nearest neighbors. Given the data set P , it finds the following property of Voronoi diagrams: all p ∈ P for which we have D(q, p) ≤ D(q, p ) where p is Property V-4: Let p , . . . , p be the k > 1 nearest points k k 1 k the k-th nearest neighbor of p in P [16]. We use RkNN(q) to of P to a point q (i.e., p is the i-th nearest neighbor of i denote the result set. Figure 3b shows point p together with q). Then, p is a Voronoi neighbor of at least one point k p and p as p’s 1st and 2nd NNs, respectively. The point p p ∈ {p , . . . , p } (p ∈ VN(p ); see [6] for a proof). 1 2 i 1 k−1 k i is closer to p than to q and hence p is not in R1NN(q). How- This property states that in Figure 2 where the first NN 1 ever, q is inside the circle centered at p with radius D(p, p ) of q is p , the second NN of q (p ) is a Voronoi neighbor of 2 14 4 and hence it is closer to p than p to p. As p is the 2nd NN p . Also, its third NN (p ) is a Voronoi neighbor of either 2 2 14 8 of p, p is in R2NN(q). p or p (or both as in this example). Therefore, once we 14 8 The TPL algorithm for RkNN search proposed by Tao et find the first NN of q we can easily explore a limited neigh- al. in [16] uses a two-step filter-refinement approach on an borhood around its Voronoi cell to find other NNs (e.g., we R-tree of points. TPL first finds a set of candidate RNN examine only Voronoi neighbors of NN(q) to find the second points S by a single traversal of the R-tree, visiting its NN of q). Figure 14 shows the pseudo-code of our VR-kNN cnd nodes in ascending distance from q and performing smart algorithm. It first uses VR-1NN to find the first NN of q pruning. The pruned nodes/points are kept in a set S (p in Figure 2a). Then, it adds this point to a minheap rfn 14 which are used during the refinement step to eliminate false H sorted on the ascending distance of each point entry to positives from S . We review TPL starting with its fil- q (H=(p , 5)). Subsequently, each following iteration re- cnd 14 tering criteria to prune the nodes/points that cannot be in moves the first entry from H, returns it as the next NN of the result. In Figure 3b, consider the perpendicular bisector q and adds all its Voronoi neighbors to H. Assuming k = 3 B(q, p ) which divides the space into two half-planes. Any in the above example, the trace of VR-kNN iterations is: 1 point such as p locating on the same half-plane as p1 (de- 1) p14 = 1st NN, add VN(p14) ⇒ H=((p4, 7), (p8, 8), (p12, 13), (p13, 18)). noted as Bp1 (q, p1)) is closer to p1 than to q. Hence, p can- 2) p4 = 2nd NN, add VN(p4) ⇒ H=((p8, 8), (p12, 13), (p6, 13), (p7, 14), not be in R1NN(q). That is, any point p in the half-plane (p5, 16), (p13, 18)). 3) p8 = 3rd NN, terminate. B (q, p ) defined by the bisector of qp for an arbitrary Correctness: The correctness of VR-kNN follows the cor- p1 1 1 point p cannot be in R1NN(q). With R1NN queries, TPL rectness of BFS and the definition of Voronoi diagrams. 1 uses this criteria to prune the points that are in B (q, p ) Complexity: We compute I/O complexities in terms of p1 1 of another point p . It also prunes the nodes N that are in Voronoi records and R-tree nodes retrieved by the algo- 1 the union of B (q, p ) for a set of candidate points p . The rithm. VR-kNN once finds NN(q) executes exactly k it- pi i i reason is that each point in N is closer to one of p ’s than erations each extracting Voronoi neighbors of one point. i to q and hence cannot be in R1NN(q). A similar reasoning Property V-3 states that the average number of these neigh- holds for general RkNN queries. Considering B (q, p ) and bors is constant. Hence, the I/O complexity of VR-kNN is p1 1 B (q, p ), p is not inside the intersection of these two half- O(Φ(|P |) + k) where Φ(|P |) is the complexity of finding 1st p2 2 planes (the region in black in Figure 3b). It is also outside NN of q using VoR-Tree (or R-tree). The time complexity the intersection of the corresponding half-planes of any two can be determined similarly. arbitrary points of P . Hence, it is not closer to any two Improvement over BFS: We show how, for the same kNN points than to q and therefore p is in R2NN(q). query, VR-kNN accesses less number of disk pages (or VoR- With R1NN query, pruning a node N using the above Tree nodes) comparing to BFS. Figure 3a shows a query criteria means incrementally clipping N by bisector lines of point q and 3 nodes of a VoR-Tree with 8 entries per node. n candidate points into a convex polygon N which takes With the corresponding R-tree, BFS accesses node N where res 1 O(n2) times. The residual region N is the part of N that it finds p , the first NN of q. To find q’s 2nd NN, BFS visits res 1 may contain candidate RNNs of q. If the computed N is both nodes N and N as their mindist is less than D(p , q) res 2 3 2 empty, then it is safe to prune N (and add it to S ). This (p is the closest 2nd NN found in N ). However, VR-kNN rfn 2 1 filtering method is more complex with RkNN queries where does not access N and N . It looks for 2nd NN in Voronoi 2 3 it must clip N with each of n
combinations of bisectors neighbors of p which are all stored in N . Even when it k 1 1 of n candidate points. To overcome this complexity, TPL returns p as 2nd NN, it looks for 3rd NN in the same node 2 uses a conservative trim function which guarantees that no as N contains all Voronoi neighbors of both p and p . The 1 1 2 possible RNN is pruned. With R1NN, trim incrementally above example represents a sample of many kNN query sce- clips the MBR of the clipped N from the previous step. narios where VR-kNN achieves a better I/O performance res With RkNN, as clipping with n
combinations, each with than BFS. k k bisector lines, is prohibitive, trim utilizes heuristics and approximations. TPL’s filter step is applied in rounds. Each 4.2 Reverse k Nearest Neighbor Query (RkNN) round first eliminates candidates of Scnd which are pruned Given a query point q, Reverse k Nearest Neighbor (RkNN) by at least k entries in Srfn. Then, it adds to the final result query retrieves all the data points p ∈ P that have q as one RkNN(q) those candidates which are guaranteed not to be 7 4 5 6

2 6 12 9 3 2 3 10 1 8 8 4 5 4 1 5 11 Figure 4: Lemma 1 6 7 pruned by any entry of Scnd. Finally, it queues more nodes from Srfn to be accessed in the next round as they might prune some candidate points. The iteration on refinement 3 2 1 rounds is terminated when no candidate left (Scnd=∅). Figure 5: VR-RkNN for k = 2 While TPL utilizes smart pruning techniques, there are contain q’s RkNNs. In Figure 5, the non-black points can- two drawbacks: 1) For k>1, the conservative filtering of not be R2NNs of q as they are farther than k=2 from q nodes in the trim function fails to prune the nodes that can in DG(P ∪{q}). We must only examine the black points as be discarded. This results into increasing the number of can- candidate R2NNs of q. However, the number of points in k didate points [16]. 2) For many query scenarios, the number graph distance from q grows exponentially with k. There- of entries kept in Srfn is much higher than the number of fore, to further limit these candidates, the filter step also candidate points which increases the workspace required for utilizes another property first proved in [15] for R1NNs and TPL. It also delays the termination of TPL as more refine- then generalized for RkNNs in [16]. In Figure 5, consider ment rounds must be performed. the 6 equi-sized partitions S1,...,S6 defined by 6 vectors Improvement over TPL: Similar to TPL, our VR-RkNN originating from q. algorithm also utilizes a filter-refinement approach. How- 2 ever, utilizing properties of Voronoi diagram of P , it elimi- Lemma 3. Given a query point q in R , the kNNs of q nates the exhaustive refinement rounds of TPL. It uses the in each partition defined as in Figure 5 are the only possible Voronoi records of VoR-Tree of P to examine only a limited RkNNs of q (see [16] for a proof). neighborhood around a query point to find its RNNs. First, The filter step adds to its candidate set only those points the filter step utilizes two important properties of RNNs that are closer than k +1 from q in DG(P ∪{q}) (Lemma 2). to define this neighborhood from which it extracts a set of From all candidate points inside each partition S (defined candidate points and a set of points required to prune false i as in Figure 5), it keeps only the k closest ones to p and hits (see Lemmas 2 and 3 below). Then, the refinement step discards the rest (Lemma 3). Notice that both filters are finds kNNs of each candidate in the latter set and eliminates required. In Figure 5, the black point p while in distance those candidates that are closer to their k-th NN than to q. 9 2 from q is eliminated during our search for R2NN(q) as it We discuss the properties used by the filter step. Consider is the 3rd closest point to q in partition S . Similarly, p , the Delaunay graph DG(P ). We define gd(p, p0) the graph 4 10 the closest point to q in S , is eliminated as gd(q, p ) is 3. distance between two vertices p and p0 of DG(P ) (points of 6 10 To verify each candidate p, in refinement step we must P ) as the minimum number of edges connecting p and p0 in examine whether p is closer to q than p’s k-th NN (i.e., DG(P ). For example, in Figure 1b we have gd(p, p0)=1 and p ). Lemma 1 states that the upper bound of gd(p, p ) is gd(p, p00)=2. k k k (gd(p, pk)≤k). Candidate p can also be k edges far from Lemma 1. Let pk6=p be the k-th closest point of set P q (gd(p, q)≤k). Hence, pk can be in distance 2k from q to a point p ∈ P . The upper bound of the graph distance (all black and grey points in Figure 5). All other points between vertices p and pk in Delaunay graph of P is k (i.e. (shown as grey crosses) are not required to filter the candi- gd(p, pk) ≤ k). dates. Thus, it suffices to visit/keep this set R and compare Proof. The proof is by induction. Consider the point p them to q with respect to the distance to each candidate p. However, visiting the points in R through VD(P ) takes ex- in Figure 4. First, for k=1, we show that gd(p, p1)≤1. Prop- ponential time as the size of R grows exponentially with k. erty V-4 of Section 4.1 states that p1 is a Voronoi neighbor of To overcome this exponential behavior, VR-RkNN finds the p; p1 is an immediate neighbor of p in Delaunay graph of P k-th NN of each candidate p which takes only O(k2) time and hence we have gd(p, p1)=1. Now, assuming gd(p, pi)≤i for at most 6k candidates. for 0≤i≤k, we show that gd(p, pk+1)≤k+1. Property V-4 Figure 15 shows the pseudo-code of the VR-RkNN algo- states that pk+1 is a Voronoi neighbor of at least one pi ∈ rithm. VR-RkNN maintains 6 sets Scnd(i) including candi- {p1, . . . , pk}. Therefore, we have gd(p, pk+1) ≤ max(gd(p, pi)) +1 ≤ k+1. date points of each partition (Line 2). Each set Scnd(i) is a minheap storing the (at most) k NNs of q inside partition In Figure 5, consider the query point q and the Voronoi Si. First, VR-RkNN finds the Voronoi neighbors of q as if diagram VD(P ∪{q})(q added to VD(P )). Lemma 1 states we add q into VD(P ) (Line 3). This is easily done using the that if q is one of the kNNs of a point p, then we have insert operation of VoR-Tree without actual insertion of q gd(p, q)≤k; p is not farther than k distance from q in Delau- (see Appendix B). nay graph of P ∪{q}. This yields the following lemma: In the filter step, VR-RkNN uses a minheap H sorted on the graph distance of its point entries to q to traverse VD(P ) Lemma 2. If p is one of reverse kNNs of q, then we have in ascending gd() from q. It first adds all neighbors p of q gd(p, q) ≤ k in Delaunay graph DG(P ∪{q}). i to H with gd(q, pi)=1 (Lines 4-5). In Figure 5, the points As the first property of RNN utilized by our filter step, p1, . . . , p4 are added to H. Then, VR-RkNN iterates over the Lemma 2 limits the local neighborhood around q that may top entry of H. At each iteration, it removes the top entry p. 3 3 3

2 2

1 1 (a) (b) 2 Figure 6: a) f=sum , b) f=max 1 If p, inside Si, passes both filters defined by Lemma 2 and 3, the algorithm adds (p, D(q, p)) to the candidate set of parti- tion Si (Scnd(i); e.g., p1 to S1). It also accesses the Voronoi (a) f=sum (b) f=max record of p through which it adds the Voronoi neighbors of Figure 7: Search Region of p for function f p to H (incrementing its graph distance; Lines 12-15). The filter step terminates when H becomes empty. In our ex- 0 0 ample, the first iteration adds p1 to Scnd(1), and p5, p6 and point p is in SR of p iff we have adist(p ,Q)≤adist(p, Q). p7 with distance 2 to H. After the last iteration, we have The equality holds on SR’s boundary (denoted as SRB). For Scnd(1) = {p1, p5}, Scnd(2) = {p6, p7}, Scnd(3) = {p4, p11}, f=sum (and weighted sum), SR has an irregular circular Scnd(4) = {p3, p8}, Scnd(5) = {p2, p12}, and Scnd(6) = {}. shape that depends on the query cardinality and distribu- The refinement step (Line 17) examines the points in each tion (an ellipse for 2 query points) [12]. For f=max, SR Scnd(i) and adds them to the final result iff they are closer to is the intersection of n circles centered at qi’s with radius= their k-th NN than to q (R2NN={p1, p2}). Finding the k-th max(D(p, qi)). The figure shows SRBs of several points as 2 NN is straightforward using an approach similar to VR-kNN contour lines defined as the locus of points p ∈ R where 0 of Section 4.1. adist(p, Q)=c (constant). As shown, SR of p is completely inside SR of p iff we have adist(p0,Q)

10000 1000

1000 100 100 10 10

numberofaccessed pages 1 1 numberaccessedof pages 1 4 16 64 1 4 16 64 (c) USGS k (d) NE k Figure 9: I/O vs. k for ab) kNN, and cd) RkNN

Figure 8: VR-kANN for k = 3 k-th visited point. This distance increases when k increases and causes many nodes intersect with SR and hence not be 5. PERFORMANCE EVALUATION pruned by BFS. VR-kNN however uses Property V-4 to de- We conducted several experiments to evaluate the perfor- fine a tighter SR. We also realized that this difference in mance of query processing using VoR-Tree. For each of four I/O costs increases if we use smaller node capacities for the NN queries, we compared our algorithm with the competi- utilized R-tree/VoR-Tree. Figure 9b shows a similar obser- tor approach, with respect to the average number of disk vation for the result of NE. I/O (page accesses incurred by the underlying R-tree/VoR- The second set of experiments evaluates the I/O cost of Tree). For R-tree-based algorithms, this is the number of VR-RkNN and TPL for RkNN queries. Figures 9c and 9d accessed R-tree nodes. For VoR-Tree-based algorithms, the depict the I/O costs of both algorithms for different values number of disk pages accessed to retrieve Voronoi records is of k using USGS and NE, respectively (the scale of y-axis also counted. Here, we do not report CPU costs as all al- is logarithmic). As shown, VR-RkNN significantly outper- gorithms are mostly I/O-bound. We investigated the effect forms TPL by at least 3 orders of magnitude, especially for of the following parameters on performance: 1) number of k>1 (to find R4NN with USGS, TPL takes 8 seconds (on NNs k for kNN, kANN, and RkNN queries, 2) number of average) while VR-RkNN takes only 4 milliseconds). TPL’s query points (|Q|) and the size of MBR of Q for kANN, and filter step fails to prune many nodes as k trim function is 3) cardinality of the dataset for all queries. highly conservative. It uses a conservative approximation We used three real-world datasets indexed by both R*- of the intersection between a node and SR. Moreover, to tree and VoR-Tree (same page size=1K bytes, node capac- avoid exhaustive examinations it prunes using only n com- n
ity=30). USGS dataset, obtained from the U.S. Geological binations of k combinations of n candidate points. Also, Survey (USGS), consists of 950, 000 locations of different TPL keeps many pruned (non-candidate) nodes/points for businesses in the entire U.S.. NE dataset contains 123, 593 further use in its refinement step. VR-RkNN’s I/O cost locations in New York, Philadelphia and Boston 1. GRC is determined by the number of Voronoi/Delaunay edges dataset includes the locations of 5, 922 cities and villages traversed from q and the distance D(q, pk) between q and in Greece (we omit the experimental result of this dataset pk=k-th closest point to q in each one of 6 directions. Unlike because of similar behavior and space limitation). The ex- TPL, VR-RkNN does not require to keep any non-candidate periments were performed by issuing 1000 random instances node/point. Instead, it performs single traversals around its of each query type on a DELL Precision 470 with Xeon 3.2 candidate points to refine its results. VR-RkNN’s I/O cost GHz processor and 3GB of RAM (buffer size=100K bytes). increases very slowly when k increases. The reason is that For convex hull computation in VR-S2, we used the Graham D(q, pq) (and hence the size of SR utilized by VR-RkNN) scan algorithm. increases very slowly with k. TPL’s performance is variable In the first set of experiments, we measured the average for different data cardinalities. Hence, our result is differ- number of disk pages accessed (I/O cost) by VR-kNN and ent from the corresponding result shown in [16] as we use BFS algorithms varying values of k. Figure 9a illustrates different datasets with different R-tree parameters. the I/O cost of both algorithms using USGS. As the fig- Our next set of experiments studies the I/O costs of VR- ure shows, utilizing Voronoi cells in VR-kNN enables the kANN and MBM for kANN queries. We used f=sum and algorithm to prune nodes that are accessed by BFS. Hence, |Q|=8 query points all inside an MBR covering 4% of the VR-kNN accesses less number of pages comparing to BFS, entire dataset and varied k. Figures 10a and 10b show the especially for larger values of k. With k=128, VR-kNN dis- average number of disk pages accessed by both algorithms cards almost 17% of the nodes which BFS finds intersecting using USGS and NE, respectively. Similar to previous re- with SR. This improvement over BFS is increasing when sults, VR-kANN is the superior approach. Its I/O cost is k increases. The reason is that the radius of SR used by almost half of that of MBM when k≤16 with USGS (k≤128 BFS’s pruning is first initialized to D(q, p) where p is the with NE dataset). This verifies that VR-kANN’s traversal of SR from the centroid point effectively covers the circu- 1http://geonames.usgs.gov/, http://www.rtreeportal.org/ lar irregular shape of SR of sum (see Figure 7a). That is, 60 VR-kANN MBM 80 VR-kANN MBM ture of R-trees. For various NN queries, we proposed I/O- 70 50 60 efficient algorithms utilizing VoR-Trees. All our algorithms 40 50 utilize the hierarchy of VoR-Tree to access the portion of 30 40 data space that contains the query result. Subsequently, 20 30 20 they use the Voronoi information associated with the points 10

numberofaccessed pages 10 at the leaves of VoR-Tree to traverse the space towards the numberofaccessed pages 0 0 actual result. Founded on geometric properties of Voronoi USGS 1 4k 16 64 256 1 4k 16 64 256 (a) (b) NE diagrams, our algorithms also redefine the search region of 80 VR-kANN MBM 80 VR-kANN MBM 70 70 NN queries to expedite this traversal. 60 60 Our theoretical analysis and extensive experiments with 50 50 40 40 real-world datasets prove that VoR-Trees enable I/O-efficient 30 30 processing of kNN, Reverse kNN, k Aggregate NN, and spa- 20 20 tial skyline queries on point data. Comparing to the com- 10 10 number of accessed pages numberofaccessed pages 0 0 petitor R-tree-based algorithms, our VoR-Tree-based algo- 0.25% 1% 2.25% 4% 16% 0.25% 1% 2.25% 4% 16% USGS NE (c) MBR(Q) (d) MBR(Q) rithms exhibit performance improvements up to 18% for Figure 10: I/O vs. ab) k, and cd) MBR(Q) for kANN kNN, 99.9% for RkNN, and 64% for kANN queries. 7. REFERENCES the traversal does not continue beyond a limited neighbor- [1] S. B¨orzs¨onyi, D. Kossmann, and K. Stocker. The Skyline hood enclosing SR. However, MBM’s conservative heuristic Operator. In ICDE’01, pages 421–430, 2001. explores the nodes intersecting a wide margin around SR [2] J. V. den Bercken, B. Seeger, and P. Widmayer. A Generic (a superset of SR). Increasing k decreases the difference be- Approach to Bulk Loading Multidimensional Index tween the performance of VR-kANN and that of MBM. The Structures. In VLDB’97, 1997. intuition here is that with large k, SR converges to a circle [3] A. Guttman. R-trees: a Dynamic Index Structure for around the centroid point q (see outer contours in Figure Spatial Searching. In ACM SIGMOD ’84, pages 47–57, 7a). That is, SR becomes equivalent to the SR of kNN with USA, 1984. ACM Press. query point q. Hence, the I/O costs of VR-kANN and MBM [4] M. Hagedoorn. Nearest Neighbors can be Found Efficiently if the Dimension is Small relative to the input size. In converge to that of their corresponding algorithms for kNN ICDT’03, volume 2572 of Lecture Notes in Computer queries with the same value for k. Science, pages 440–454. Springer, January 2003. The last set of experiments investigates the impact of [5] G. R. Hjaltason and H. Samet. Distance Browsing in closeness of the query points on the performance of each Spatial Databases. ACM TODS, 24(2):265–318, 1999. kANN algorithm. We varied the area covered by the MBR(Q) [6] M. Kolahdouzan and C. Shahabi. Voronoi-Based K Nearest from 0.25% to 16% of the entire dataset. With f=sum Neighbor Search for Spatial Network Databases. In and |Q|=k=8, we measured the I/O cost of VR-kANN and VLDB’04, pages 840–851, Toronto, Canada, 2004. MBM. As Figures 10c and 10d show, when the area covered [7] S. Berchtold, B. Ertl, D. A. Keim, H. Kriegel, and T. Seidl. Fast Nearest Neighbor Search in High-Dimensional Space. by query points increases, VR-kANN accesses much less disk In ICDE’98, pages 209–218, 1998. pages comparing to MBM. The reason is a faster increase in [8] F. Korn and S. Muthukrishnan. Influence Sets based on MBM’s I/O cost. When the query points are distributed in a Reverse Nearest Neighbor Queries. In ACM SIGMOD’02, larger area, the SR is also proportionally large. Hence, the pages 201–212. ACM Press, 2000. larger wide margin around SR intersects with much more [9] S. Maneewongvatana. Multi-dimensional Nearest Neighbor nodes leaving them unpruned by MBM. We also observed Searching with Low-dimensional Data. PhD thesis, that changing the number of query points in the same MBR Computer Science Department, University of Maryland, does not change the I/O cost of MBM. This observation College Park, MD, 2001. [10] A. Okabe, B. Boots, K. Sugihara, and S. N. Chiu. Spatial matches the result reported in [12]. Similarly, VR-kANN’s Tessellations, Concepts and Applications of Voronoi I/O cost is the same for different query sizes. The reason is Diagrams. John Wiley and Sons Ltd., 2nd edition, 2000. that VR-kANN’s I/O is affected only by the size of SR. In- [11] D. Papadias, Y. Tao, G. Fu, and B. Seeger. Progressive creasing the number of query points in the same MBR only Skyline Computation in Database Systems. ACM TODS, changes the shape of SR not its size. 30(1):41–82, 2005. The extra space required to store Voronoi records of data [12] D. Papadias, Y. Tao, K. Mouratidis, and C. K. Hui. points in VoR-Trees increases the overall disk space com- Aggregate Nearest Neighbor Queries in Spatial Databases. paring to the corresponding R-Tree index structure for the ACM TODS, 30(2):529–576, 2005. [13] N. Roussopoulos, S. Kelley, and F. Vincent. Nearest same dataset. The Vor-Trees (R*-trees) of USGS and NE Neighbor Queries. In SIGMOD’95, pages 71–79, USA, 1995. datasets are 160MB (38MB) and 23MB (4MB), respectively. [14] M. Sharifzadeh and C. Shahabi. The Spatial Skyline That is, a Vor-Tree needs at least 5 times more disk space Queries. In VLDB’06, September 2006. than the space needed to index the same dataset using an [15] I. Stanoi, D. Agrawal, and A. E. Abbadi. Reverse Nearest R*-Tree. Considering the low cost of storage devices and Neighbor Queries for Dynamic Databases. In ACM high demand for prompt query processing, this space over- SIGMOD Workshop on Research Issues in Data Mining head is acceptable to modern applications of today. and Knowledge Discovery, pages 44–53, 2000. [16] Y. Tao, D. Papadias, and X. Lian. Reverse kNN Search in 6. CONCLUSIONS Arbitrary Dimensionality. In VLDB’04, pages 744–755, 2004. We introduced VoR-Tree, an index structure that incor- [17] J. Xu, B. Zheng, W.-C. Lee, and D. L. Lee. The D-Tree: An porates Voronoi diagram and Delaunay graph of a set of Index Structure for Planar Point Queries in Location Based data points into an R-tree that indexes their geometries. Wireless Services. IEEE TKDE, 16(12):1526–1542, 2004. VoR-Tree benefits from both the neighborhood exploration [18] B. Zheng and D. L. Lee. Semantic Caching in Location capability of Voronoi diagrams and the hierarchical struc- -dependent Query Processing. In SSTD’01, pages 97–116. 11 4 5 13 7 9 10 p ) 2 mindist(N7 , q) q ,

6 v v2 3 N

(

t

s 12 i d p n 1 x 3 6 i p m 3 14 v1 v4

8 p4 2 6 4 3

1 5 2 Figure 12: Inserting the point x in VoR-Tree 1 7 Algorithm VR-1NN (point q) 01. minheap H = {(R, 0)}; bestdist = ∞; R e e 02. WHILE H is not empty DO 6 7 03. remove the first entry e from H;

N e1 e2 e3 e4 e5 N 04. IF e is a leaf node THEN 6 7 05. FOR each point p of e DO N1 N2 N3 N4 N5 p p p p p p p p p p p p p p 06. IF D(p, q) < bestdist THEN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 07. bestNN = p; bestdist = D(p, q); Figure 11: Points indexed by an R-tree 08. IF V (bestNN) contains q THEN RETURN bestNN; 09. ELSE // e is an intermediate node APPENDIX 10. FOR each child node e0 of e DO 11. insert (e0, mindist(e0, q)) into H; A. R-TREES Figure 13: 1NN algorithm using VoR-Tree R-tree [3] is the most prominent index structure widely used for d spatial query processing. R-trees group the data points in R us- ing d-dimensional rectangles, based on the closeness of the points. Figure 11 shows the R-tree built using the set P = {p1, . . . , p13} of process to p3 and p4 until p1 is selected again. At this point 2 points in R . Here, the capacity of each node is three entries. The the algorithm terminates and as the result it updates the Voronoi leaf nodes N1,...,N5 store the coordinates of the grouped points records of points pi and computes V (x) as the regions removed together with optional pointers to their corresponding records. from the clipped cells. The Voronoi neighbors of x are also set Each intermediate node (e.g., N6) contains the Minimum Bound- to the set of generator points of updated Voronoi cells. Finally, ing Rectangle (MBR) of each of its child nodes (e.g., e1 for node we store the updated Voronoi cells and neighbors in the Voronoi N1) and a pointer to the disk page storing the child. The same records corresponding to the affected points. Notice that find- grouping criteria is used to group intermediate nodes into upper ing the affected points p1, . . . , p4 is straightforward using Voronoi level nodes. Therefore, the MBRs stored in the single root of neighbors and the geometry of Voronoi cells stored in VoR-Tree. R-tree collectively cover the entire data set P . In Figure 11, the To delete a point x from VoR-Tree, we first locate the Voronoi root node R contains MBRs e6 and e7 enclosing the points in record of x using the corresponding R-tree. Then, we access its nodes N6 and N7, respectively. Voronoi neighbors through this record. The cells and neighbors of R-tree-based algorithms utilize some metrics to bound their these points must be updated after deletion of x. To perform this search space using the MBRs stored in the nodes. The widely used update, we use the algorithm in [10]. It simply uses the intersec- function is mindist(N, q) which returns the minimum possible tions of perpendicular bisectors of each pair of neighbors of x to distance between a point q and any point in the MBR of node update their Voronoi cells. We also remove x from the records of N. Figure 11 shows mindist(N6, q) and mindist(N7, q) for q. In its neighbors and add any possible new neighbor to these records. Section 4, we show how R-tree-based approaches use this lower- At this point, it is safe to delete x from the corresponding R-tree. bound function. The update operation of VoR-Tree to change the location of x is performed using a delete followed by an insert. The average time and I/O complexities of all three operations are constant. B. VOR-TREE MAINTENANCE With both insert and delete operations, only Voronoi neighbors Given the set of points P , the batch operation to build the VoR- of the point x (and hence its Voronoi record) are changed. These Tree of P first uses a classic approach such as Fortune’s sweepline changes must also be applied to the Voronoi records of these algorithm [10] to build the Voronoi diagram of P . The Voronoi points which are directly accessible through that of x. According neighbors and the vertices of the cell of each point is then stored to Property V-3, the average number of Voronoi neighbors of a in its record. Finally, it easily uses a bulk construction approach point is six. Therefore, the average time and I/O complexities of for R-trees [2] to index the points in P considering their Voronoi insert/delete/update operations on VoR-Trees are constant. records. The resulted R-tree is the VoR-Tree of P . To insert a new point x in a VoR-Tree, we first use VoR-Tree (or the corresponding R-tree) to locate p, the closest point to x C. KNN QUERY in the set P . This is the point whose Voronoi cell includes x. Figures 13 and 14 show the pseudo-code of VR-1NN and VR- Then, we insert x in the corresponding R-tree. Finally, we need kNN, respectively. to build/store Voronoi cell/neighbors of x and subsequently up- date those of its neighbors in their Voronoi records. We use the algorithm for incremental building of Voronoi diagrams presented in [10]. Figure 12 shows this scenario. Inserting the point x resid- Algorithm VR-kNN (point q, integer k) ing in the Voronoi cell of p , changes the Voronoi cells/neighbors 01. NN(q) = VR-1NN(q); 1 02. minheap H = {(NN(q),D(NN(q), q))}; (and hence the Voronoi records) of points p1, p2, p3 and p4. We first clip V (p ) using the perpendicular bisector of line segment 03. V isited = {NN(q)}; counter = 0; 1 04. WHILE counter < k DO xp1 (i.e., line B(x, p1)) and store the new cell in p1’s record. We 05. remove the first entry p from H; also update Voronoi neighbors of p1 to include the new point x. 06. OUTPUT p; increment counter; Then, we select the Voronoi neighbor of p1 corresponding to one 07. FOR each Voronoi neighbor of p such as p0 DO of (possibly two) Voronoi edges of p1 that intersect with B(x, p1) 08. IF p0 ∈/ V isited THEN (e.g., p2). We apply the same process using the bisector line 09. add (p0,D(p0, q)) into H and p0 into V isited; B(x, p2) to clip and update V (p2). Subsequently, we add x to the Voronoi neighbors of p2. Similarly, we iteratively apply the Figure 14: kNN algorithm using VoR-Tree Algorithm VR-RkNN (point q, integer k) (e.g., for f=max it is the center of smallest circle containing Q), 01. minheap H = {}; V isited = {}; VR-kANN performs a 1NN search using VoR-Tree and retrieves 02. FOR 1 ≤ i ≤ 6 DO minheap Scnd(i) = {}; pq. However, for many functions f, the centroid q cannot be pre- 03. VN(q) = FindVoronoiNeighbors(q); cisely computed [12]. With f=sum, q is the Fermat-Weber point 04. FOR each point p in VN(q) DO which is only approximated numerically. As VR-kANN only re- 05. add (p, 1) into H; add p into V isited; quires the closest point to q (not q itself), we provide an algorithm 06. WHILE H is not empty DO similar to gradient descent to find p 2. Figure 17 illustrates this 07. remove the first entry (p, gd(q, p)) from H; q 08. i = sector around q that contains p ; algorithm. We first start from a point close to q and find its 09. p = last point in S (i) (infinity if empty); closest point p1 using VR-1NN (e.g., the geometric centroid of Q n cnd with x = (1/n) Pn q .x and y = (1/n) Pn q .y) for f=sum). 10. IF gd(q, p) ≤ k and D(q, p) ≤ D(q, p ) THEN i=1 i i=1 i n Second, we compute the partial derivatives of f=adist(q, Q) with 11. add (p, D(q, p)) to Scnd(i); 12. FOR each Voronoi neighbor of p such as p0 DO respect to variables q.x and q.y: 13. IF p0 ∈/ V isited THEN 0 ∂adist(q,Q) Pn (x−xi) 14. gd(q, p ) = gd(q, p) + 1; ∂x = = √ ∂x i=1 (x−x )2+(y−y )2 15. add (p0, gd(q, p0)) into H and p0 into V isited; i i (2) ∂ = ∂adist(q,Q) = Pn √ (y−yi) y ∂y i=1 2 2 16. FOR each candidate set Scnd(i) DO (x−xi) +(y−yi) 17. FOR the first k points in Scnd(i) such as p DO 18. pk = k-th NN of p; Computing ∂x and ∂y at point p1, we get a direction d1. Draw- 19. IF D(q, p) ≤ D(pk, p) THEN OUTPUT p ; ing a ray r1 originating from p1 in direction d1 enters the Voronoi Figure 15: RkNN algorithm using VoR-Tree cell of p2 intesecting its boundary at point x1. We compute the direction d2 at x1 and repeat the same process using a ray r2 orig- inating from x1 in direction d2 which enters V (pq) at x2. Now, Algorithm VR-kANN (set Q, integer k, function f) as we are inside V (pq) that includes centroid q, all other rays 01. pq = FindCentroidNN(Q, f); consecutively circulate inside V (pq). Detecting this situation, we 02. minheap H = {(pq, 0)}; return pq as the closest point to q. 03. minheap RH = {(pq, adist(pq,Q))}; 04. V isited = {pq}; counter = 0; Minimum aggregate distance in a Voronoi cell: The func- 05. WHILE H is not empty DO tion amindist(V (p),Q) can be conservatively computed as adist( 06. remove the first entry p from H; 0 vq1, . . . , vqn) where vqi=mindist(V (p), qi) is the minimum dis- 07. WHILE the first entry p of RH has tance between q and any point in V (p). However, when the cen- 08. adist(p0,Q) ≤ amindist(V (p),Q) DO i 0 0 troid q is outside V (p), minimum adist() happens on the bound- 09. remove p from RH; output p ; ary of V (p). Based on this fact, we find a better lower-bound for 10. increment counter; if counter = k terminate; 11. FOR each Voronoi neighbor of p such as p0 DO amindist(V (p),Q). For point p1 in Figure 17, if we compute the 0 direction d1 and ray r1 as stated for centroid computation, we re- 12. IF p ∈/ V isited THEN 0 0 0 13. add (p0, amindist(V (p0),Q)) into H; alize that amindist(p ,Q)(p ∈ V (p)) is minimum for a point p 0 0 on the edge v1v2 that intersects with r1. The reason is the circular 14. add (p , adist(p ,Q)) into RH; convex shape of SRs for adist(). Therefore, amindist(V (p),Q) re- 15. add p0 into V isited; turns adist(vq1, . . . , vqn) where vqi=mindist(v1v2, qi) is the min- Figure 16: kANN algorithm using VoR-Tree imum distance between qi and the Voronoi edge v1v2. Correctness:

D. RKNN QUERY Lemma 5. Given a query point q, VR-kANN correctly and in- Figure 15 shows the pseudo-code of VR-RkNN. crementally finds kANN(q) in the ascending order of their adist() Correctness: values. Lemma 4. Given a query point q, VR-RkNN correctly finds Proof. It suffices to show that when VR-kANN reports p, it RkNN(q). has already examined/reported all the points p0 where adist(p0,Q) ≤ adist(p, Q). VR-kANN reports p when for all the cells V in H, Proof. It suffices to show that the filter step of VR-RkNN is we have amindist(V,Q) ≥ adist(p, Q). That is, all these visited safe. This follows building the filter based on Lemmas 1, 2, and cells are outside SR of p. In Figure 17, p2 is reported when H 3. contains only the cells on the boundary of the grey area which contains SR of p . As VR-kANN starts visiting the cells from the Complexity: VR-RkNN once finds NN(q) starts finding k clos- 2 V (p ) containing centroid q, when reporting any point p, it has est points to q in each partition. It requires retrieving O(k) q already examined/inserted all points in SR of p in RH. As RH Voronoi records to find these candidate points as they are at is a minheap on adist(), the results are in the ascending order of most k edges far from q. Finding k NN of each candidate point their adist() values. also requires accessing O(k) Voronoi records. Therefore, the I/O complexity of VR-RkNN is O(Φ(|P |) + k2) where Φ(|P |) is the complexity of finding NN(q). Complexity: The Voronoi cells of visited points constitute an almost-minimal set of cells covering SR of result (including k points). These cells are in a close edge distance to the returned k E. KANN QUERY points. Hence, the number of points visited by VR-kANN is O(k). Figure 16 shows the pseudo-code of VR-kANN. Therefore, the I/O complexity of VR-kANN is O(Φ(|P |) + k) Centroid Computation: When q can be exactly computed where Φ(|P |) is the complexity of finding the closest point to cen- troid q.

General aggregate functions: In general, any kANN query with an aggregate function for which SR of a point is continuous is supported by the pseudo-code provided for VR-kANN. This covers a large category of widely used functions such as sum, max and weighted sum. With functions such as f=min, each SR consists of n different circles centered at query points of Q. Figure 17: Finding the cell containing centroid q 2[12] uses a similar approach to approximate the centroid. N 2 p2 Algorithm VR-S (set Q, function f) p p 01. compute the convex hull CH(Q); C(q , p ) 1 p3 1 p3 1 1 02. pq = FindCentroidNN(Q, f); q q 2 2 03. minheap H = {(pq, 0)}; q q 1 1 04. minheap RH = {(pq, adist(pq,Q))}; 05. set S(Q) = {}; V isited = {pq}; 06. WHILE H is not empty DO Dominance region of p (a) 1 (b) 07. remove the first entry p from H; 0 Figure 18: Dominance regions of a) p1, and b) {p1, p3} 08. WHILE the first entry p of RH has adist(p0,Q) ≤ amindist(V (p),Q) DO As the result, Q has more than one centroid for function f. To 09. remove p0 from RH; answer a kANN query with these functions, we need to change 10. IF p0 is not dominated by S(Q) THEN 0 VR-kANN to perform parallel traversal of VD(P ) starting from 11. add p into S(Q); 0 the cells containing each of nc centroids. 12. FOR each Voronoi neighbor of p such as p DO 13. IF p0 ∈/ V isited THEN 14. add p0 into V isited; F. SPATIAL SKYLINE QUERY (SSQ) 15. IF V (p0) is not dominated by S(Q) and RH THEN 0 0 Given the set Q = {q1, . . . , qn} of query points, the Spatial 16. add (p , amindist(V (p ),Q)) into H; Skyline (SSQ) query returns the set S(Q) including those points 17. IF p0 is a definite skyline point or of P which are not spatially dominated by any other point of P . p0 is not dominated by S(Q) and RH THEN 0 0 0 0 The point p spatially dominates p iff we have D(p, qi) ≤ D(p , qi) 18. add (p , adist(p ,Q)) into RH; 0 for all qi ∈ Q and D(p, qj ) < D(p , qj ) for at least one qj ∈ Q [14]. 19. WHILE RH is not empty DO Figure 18a shows a set of nine data points and two query points 20. remove the first entry p0 from RH; 0 q1 and q2. The point p1 spatially dominates the point p2 as both 21. IF p is not dominated by S(Q) THEN 0 q1 and q2 are closer to p1 than to p2. Here, S(Q) is {p1, p3}. 22. add p into S(Q); Consider circles C(q , p ) centered at the query point q with i 1 i Figure 19: SSQ algorithm using VoR-Tree radius D(qi, p1). Obviously, qi is closer to p1 than any point outside C(qi, p1). Therefore, p1 spatially dominates any point such as p2 which is outside all circles C(qi, pi) for all qi ∈ Q (the in SSQ. This is the region that may contain points that are not grey region in Figure 18a) For a point p, this region is referred as spatially dominated by a point of S. Therefore, SR is easily the the dominance region of p [14]. complement of the dominance region of S (white region in Figure SSQ was introduced in [14] in which two algorithms B2S2 and 18b). It is straightforward to see that SR of S is a continuous VS2 were proposed. Both algorithms utilize the following facts: region as it is defined based on the union of a set of concentric circles C(qi, pi). Lemma 6. Any point p ∈ P which is inside the convex hull of An I/O-efficient algorithm once finds a set of skyline points 3 Q (CH(Q)) or its Voronoi cell V (p) intersects with CH(Q) is S must examine only the points inside the SR of S. Our VR- a skyline point (p ∈ S(Q). We use definite skyline points to refer S2 algorithm shown in Figure 19 satisfies this principle. VR-S2 to these points. reports skyline points in the ascending order of a user-provided monotone function f=adist(). It maintains a result minheap RH Lemma 7. The set of skyline points of P depends only on the that includes the candidate skyline points sorted on adist() values. set of vertices of the convex hull of Q (denoted as CHv(Q)). To maintain the order of output, we only add these candidate points into the final ordered S(Q) when no point with less adist() 2 2 The R-tree-based B S is a customization of a general skyline can be found. algorithm, termed BBS, [11] for SSQ. It tries to avoid expensive The algorithm’s traversal of VD(P ) is the same as that of VR- dominance checks for the definite skyline points inside CH(Q), kANN with aggregate function adist() (compare the two pseudo- identified in Lemma 6, but also prunes unnecessary query points codes). Likewise, VR-S2 uses a minheap H sorted on amindist( 2 to reduce the cost of each examination (Lemma 7). VS employs V (p),Q). It starts this traversal from a definite skyline point the Voronoi diagram of the data points to find the first skyline which is immediately added to the result heap RH. This is the point whose local neighborhood contains all other points of the point pq whose Voronoi cell contains the centroid of function f skyline. The algorithm traverses the Voronoi diagram of data (here, f=sum). points of P in the order specified by a monotone function of their 2 2 At each iteration, VR-S deheaps the first entry p of H (Line distances to query points. Utilizing VD(P ), VS finds all definite 0 skyline points without any dominance check. 7). Similar to VR-kANN, it examines any point p in RH whose 0 While both B2S2 and VS2 are efficiently processing SSQs, there adist() is less than p’s key (amindist(V (p),Q)) (Line 8). If p are two drawbacks: 1) B2S2 still uses the rectangular grouping is not dominated by any point in S(Q), it adds p0 to S(Q) (see of points together with conservative mindist() function in its fil- Lemma 8). Similar to B2S2 and VS2, for dominance checks VR- 2 ter step and hence, similar to MBM for kANN queries, it fails to S employs only the vertices of convex hull of Q (CHv(Q)) in- prune many nodes. To show a scenario, we first define the domi- stead of the entire Q (Lemma 7). Subsequently, accessing p’s nance region of a set S as the union of the dominance regions of all points of S (grey region in Figure 18b for S={p , p }). Any point Voronoi records, it examines unvisited Voronoi neighbors of p 1 3 0 0 in this region is spatial dominated by at least one point p ∈ S. (Line 12). For each neighbor p , if V (p ) is dominated by any Now, consider the MBR of R-tree node N in Figure 18b. B2S2 point in S(Q) or RH (discussed later), VR-S2 discards p0. The 0 does not prune N (visits N) as we have mindist(N, q2) D(p1, q1) = 2, mindist(V (p13), q2) = 16 > D(p1, q2) = 15, mindist(V (p13), q3) = 33 > D(p1, q3) = 23.

Correctness: Lemma 8. Given a query set Q, VR-S2 correctly and in- crementally finds skyline points in the ascending order of their adist() values. Proof. To prove the order, notice that VR-S2’s traversal is the same as VR-kANN’s traversal. Thus, according to Lemma 5 the result is in the ascending order of adist(). To prove the correctness, we first prove that if p is a sky- line point (p ∈ S(Q)) then p is in the result returned by VR-S2. The algorithm examines all the points in the SR of the result it returns which is a superset of the actual S(Q). As any un-dominated point is in this SR, VR-S2 adds p to its result. Then, we prove if VR-S2 returns p, then we have p is a real skyline point. The proof is by contradic- tion. Assume that p is spatially dominated by a skyline point p0. Earlier, we proved that VR-S2 returns p0 at some point as it is a skyline point. We also proved that when VR- S2 adds p to its result set, it has already reported p0 as we have adist(p0,Q)