Continuous Visible k Nearest Neighbor Query on Moving Objects

Transcription

1 Continuous Visible k Nearest Neighbor Query on Moving Objects Yaniu Wang a, Rui Zhang b, Chuanfei Xu a, Jianzhong Qi b, Yu Gu a, Ge Yu a, a Deartment of Comuter Software and Theory, Northeastern University, China. b Deartment of Comuting and Information Systems, University of Melbourne, Australia. Abstract A visible k nearest neighbor (VkNN) uery retrieves k objects that are visible and nearest to the uery object, where visible means that there is no obstacle between an object and the uery object. Existing studies on the VkNN uery have focused on static data objects. In this aer we investigate how to rocess the uery on moving objects continuously. We roose an effective filtering-andrefinement framework for evaluating this tye of ueries. We exloit satial roximity and visibility roerties between the uery object and data objects to rune search sace under this framework. A detailed cost analysis and a comrehensive exerimental study are conducted on the roosed framework. The results validate the effectiveness of the runing techniues and verify the efficiency of the roosed framework. The roosed framework outerforms a straightforward solution by an order of magnitude in terms of both communication and comutation costs. Keywords: Satio-temoral databases, continuous visible k nearest neighbor ueries, safe region, invisible time eriod 1. Introduction The visible k nearest neighbor (VkNN) uery has attracted great research interest [12, 11, 19, 20] recently due to emerging alications such as security camera lacement and sightseeing site recommendation. This uery assumes a set P of data objects, a set O of obstacles (reresented by line segments) and a uery object. Then it retrieves k data objects from P that are visible and nearest to. Figure 1 gives an examle. Suose k = 2. The data objects are listed according to their Euclidean distance to as: 5, 6, 4, 3, 1,. Since 5, 4 and 1 are blocked by the obstacles and invisible to, they are not answers to the VkNN uery. The VkNN set of, denoted by VkNN(), is { 6, 3 }. In this aer we study a continuous version of the VkNN uery, namely, the continuous VkNN uery, which comutes the VkNN from a set of moving objects for a moving uery object continuously (i.e., for every timestam). The continuous VkNN uery has various alications. For examle, in a military simulation, there can be more than 100,000 moving objects [35] such as soldiers and military vehicles interacting with each other. A soldier needs to kee track of his/her nearest visible enemies, so that he/she can attack or avoid them. As the soldier and the enemies are moving constantly, the simulator needs to monitor them continuously and reort to the soldier his/her nearest visible enemies. In another examle, massively multilayer online first- Corresonding author. Tel.: addresses: wangyaniu@ise.neu.edu.cn (Yaniu Wang), rui@csse.unimelb.edu.au (Rui Zhang), chuanfeixu@research.neu.edu.cn (Chuanfei Xu), jii@csse.unimelb.edu.au (Jianzhong Qi), guyu@ise.neu.edu.cn (Yu Gu), yuge@ise.neu.edu.cn (Ge Yu) o 3 o 1 o Figure 1: VkNN() = { 6, 3, } (k = 2) erson shooter (MMOFPS) games like CrossFire 1 need to show a layer his/her nearby visible layers so that he/she can shoot them. Again, as the layers are moving constantly, the game system needs to monitor the layers continuously and reort to the layer his/her nearest visible layers. There may be millions of layers [9] online at the same time. Therefore, a highly efficient algorithm is reuired to rovide nearest-visible-layer monitoring in real time. The continuous VkNN uery is interesting not only for its real alications but also for the technical challenges it raises. To the best of our knowledge, there is no existing work considering the uery on moving objects. The main challenge here is that the uery result needs to be u-to-date at every timestam, which incurs significant communication and comutation costs. To mitigate the costs, we roose a filtering-and-refinement uery rocessing framework, and exloit satial roximity and visibility roerties between the uery object and the data objects to rune search sace under the framework. For satial roximity based runing, we use the safe region, which is a circular region centered at an object and is defined to bound the 1 htt://crossfire.z8games.com/ Prerint submitted to Information Systems July 31, 2013

2 movement of the object for a certain eriod of time T (cf. Figure 2). The safe regions that are close and visible to the uery object further define a runing region, which can be used to rule out objects that are too far away to be in the VkNN set within T timestams. For objects that survive the safe region based runing, their distance to the uery object is not too far, but they may still be invisible to the uery object due to obstacles. This motivates the visibility based runing, which utilizes suberiods within T that an object is invisible to the uery object, so that the object can be excluded from the VkNN candidates during those sub-eriods. We call such sub-eriods the invisible time eriods. All runing techniues together kee the number of objects that ass the filtering stage small, and hence substantially reduce the costs of the refinement stage. As a result, we achieve a highly efficient uery rocessing framework. 1 o 3 safe regions 3 4 o 1 5 o 2 6 Figure 2: Safe regions We summarize the contributions of this aer as follows. This is the first study that addresses the continuous VkNN uery on moving objects. We roose a filtering-andrefinement framework that can rocess the uery effectively. We develo two runing strategies, namely, safe region based runing and invisible time eriod based runing, to reduce the search sace for uery rocessing under the roosed framework. We conduct a detailed cost analysis for the roosed runing techniues. Extensive exeriments using both real and synthetic data sets demonstrate the high efficiency of the runing techniues as well as the roosed uery rocessing framework. The rest of this aer is structured as follows. We first review related work in Section 2. Then we formalize the continuous VkNN uery on moving objects and resent the filtering-andrefinement framework in Section 3. In Section 4, we resent two runing strategies under the framework and in Section 5 we rovide a cost analysis for algorithms based on these runing strategies. We reort the exerimental results in Section 6 and conclude the aer in Section Related Work 2 We review three classes of related studies, namely, continuous satial ueries in general, continuous k nearest neighbor ueries on moving objects and visible k nearest neighbor ueries on static objects Continuous Satial Queries in General There is a large body of literature on continuous evaluation of satial ueries. For examle, Šaltenis et al. [28] roose the Time Parameterized R-tree (TPR-tree) that indexes moving oints as linear functions of time, based on which timearameterized ueries [25] are roosed to retrieve moving objects that satisfy certain time-arameterized redicates continuously. Hu et al. [15] roose a safe region based framework for monitoring continuous satial ueries over moving objects on a client-sever based system. Each moving object (a client) in the system is aware of the current uery result and only reorts its new location to the server if it is likely to cause changes to the uery result. Mokbel et al. [16, 17] roose two frameworks for rocessing continuous satial ueries. They rocess the ueries incrementally by comuting the effect of each individual udate on the uery answer. They also roose shared execution techniues to rocess multile ueries at the same time. Benetics et al. [6] study the roblem of continuous reverse nearest neighbor (RNN) monitoring over moving objects. Xia et al. [30] also study the continuous RNN uery. They roose a so-called sixregion aroach to rocess the uery. Later, Cheema et al. [8] roose a safe region based aroach to rocess the continuous reverse k nearest neighbor (RkNN) uery. More recently, Zhang et al. [35] study the continuous intersection join uery, which reorts the set of intersecting objects from two moving object sets continuously Continuous k Nearest Neighbor Queries on Moving Objects As a major tye of continuous satial ueries, the continuous k nearest neighbor (knn) uery on moving objects has been studied extensively. For examle, Tao et al. [26] consider a continuous NN search that retrieves the NNs of every oint on a given line segment. Song et al. [24] roose a samlingbased aroach to reduce the cost of rocessing continuous NN ueries. However, this method may roduce inaccurate uery answers. Zhang et al. [33] use the validity region to enable mobile clients to determine the validity of revious NN uery results based on their current locations. Nutanong et al. [21, 22] use an incremental-safe-region based techniue called the V - Diagram that exloits both the location of the uery object and the scoe of the current search sace to answer moving knn ueries. Yu et al. [32] use grid indices for monitoring knn ueries on moving objects, which can rovide exact uery answers but with a delay in the time. Xiong et at. [31] also use grid indices for monitoring continuous knn ueries. They comute the uery answer incrementally by maintaining an answer region for each uery. The location udates of objects at each timestam are used to udate the answer region, which is then used to generate udates to the uery answer. In addition, Mouratidis et al. [18] roose a threshold based algorithm for the continuous NN uery, which aims at minimizing the communication overhead between the uery rocessor and the moving objects. Further more, Hsueh et al. [14] resent a artition

3 based lazy udate algorithm that uses Location Information Tables and safe regions to rocess continuous NN ueries. There are also many studies on variants of the continuous knn uery. For examle, Zhang et al. [34] study the redictive moving knn uery. Hashem et al. [13] study how to rotect a user s location rivacy in moving knn monitoring systems. Shahabi and Sharifzadeh [23] roose the VoR-Tree, which incororates Voronoi diagrams into the R-tree to imrove the efficiency of rocessing various tyes of knn ueries. Al-Amri et al. [1, 3] study knn ueries in indoor sace. They roose an adjacency index structure for moving objects in indoor sace that takes into account both satial and temoral roerties. They use a non-leaf node timestaming method to store moving data and rocess knn ueries. In addition, Al-Amri et al. [2] roose a moving object index and a looku table that can be used to rocess traditional knn ueries as well as the novel direction and velocity ueries. Since these studies do not consider obstacles in the continuous knn uery, their methods do not aly to our roblem Visible k Nearest Neighbor Queries on Static Objects The visible k nearest neighbor (VkNN) uery is first roosed by Nutanong et al. [19]. This uery retrieves the nearest k static objects that are visible to a static uery object. To rocess the uery, Nutanong et al. [19] roose an algorithm that starts from retrieving the nearest object and then incrementally obtains the knowledge of visibility while finding other nearest neighbors. Nutanong et al. [20] also study the aggregate VkNN uery and roose an aroach named single retrieval front to rocess the uery. Besides, Gao et al. [10] study the visible reverse k nearest neighbor (VRkNN) uery, which finds all objects regarding the uery object as a member of their VkNN sets. In another aer [12], Gao et at. study the continuous visible nearest neighbor (CVNN) uery. They assume static data objects and a uery object moving along a given line segment, and use a branch-and-bound techniue to rocess the CVNN uery based on 7 runing heuristics. Among the 7 runing heuristics, 4 are based on the distance between the static data objects and the line segment where moves along, while the other 3 are based on the osition relationshi between the static data objects, an obstacle and. Since we do not assume a line segment for or static data objects, these runing heuristics do not aly. 3. Preliminaries In this section, we formulate the continuous VkNN uery on moving objects and resent an efficient filtering-and-refinement framework to rocess the uery. We summarize the symbols freuently used in the following discussion in Table Problem Formulation We first define the concet of visibility between two objects. We assume that obstacles are line segments while data objects including the uery object are oints in a two-dimensional Euclidean sace. 3 Definition 1. (Visibility). Given a set O of obstacles, we say that two objects and are visible to each other iff there is no obstacle o in O such that the line segment connecting and, denoted by, intersects o, i.e., o O, o =. Similarly, we say that and are invisible to each other iff there is an obstacle o such that intersects o, i.e., o O, o. We use V() to denote the visible region of, i.e., the region inside which all oints are visible to (cf. the white region in Figure 2). By checking whether resides in V(), we know whether is visible to. Similarly, we use I() to denote the invisible region of inside which all oints are invisible to (cf. the grey region in Figure 2). We follow the classical techniue to comute V() [4, 27]. The techniue uses the obstacles and the lines that ass through and the endoints of the obstacles to cli the invisible region of from the whole data sace. The remaining art of the data sace is the visible region of. We define the visible distance (VD) to reresent the distance between two objects when their visibility is taken into consideration. { dist(, ) is visible to VD(, ) = otherwise. Here, dist(, ) denotes the Euclidean distance between two oints and. Given the definition of visible distance, we define the continuous visible k nearest neighbor uery on moving objects as follows. Definition 2. (Continuous Visible k Nearest Neighbor (CVkNN) uery on moving objects) Given a set P of moving objects, a set O of obstacles and a moving uery object, at every timestam, the continuous visible k nearest neighbor uery retrieves a subset of P, denoted by VkNN(), such that: (i) VkNN() = k; (ii) VkNN(), is visible to ; (iii) VkNN() and P \ VkNN(), VD(, ) VD(, ). System architecture. We consider rocessing the CVkNN uery for two tyes of systems, centralized systems and clientserver based systems. Centralized systems are commonly used in alications such as military simulations, where the simulation system usually controls the moving objects directly and has all u-to-date object location information it needs to rocess the CVkNN uery. Client-server based systems are commonly used in alications such as multilayer online games, where most of the moving objects are avatars controlled by human layers through game clients (local comuters or lay stations), while the CVkNN uery is rocessed in the game server. In this case, communication cost is incurred when the server and the clients exchange location udates and uery results. For the algorithm design and cost analysis in the rest of this aer, we assume a client-server based system for ease of resentation, i.e., we will consider comutation cost as well as communication cost. However, the algorithm design rinciles and cost analysis also aly to centralized systems, in which

4 Symbol P O o VD(, ) R R V() V(R ) I() I(R ) MinVD(R, R ) MaxVD(R, R ) S c T τ τ l τ m Definition a set of moving objects a set of obstacles (line segments) a moving object an obstacle a uery object a line segment that connects and the length of (the Euclidean distance between and ) the visible distance between and the safe region of the safe region of the visible region of the visible region of R the invisible region of the invisible region of R the minimum visible distance between R and R the maximum visible distance between R and R a set of uery answer candidate objects the global maximum seed the recomutation eriod of S c an invisible time eriod of an invisible time eriod lower bound of a moving direction aware invisible time eriod of Table 1: Freuently Used Symbols case communication cost is relaced by the cost of accessing the object location data within the centralized systems. We also assume that the CVkNN uery is rocessed in main memory. This is reasonable because storing a data set of 100,000 objects only takes several MB while currently a commodity comuter usually has several GB of main memory. Then comuting the visible distance and sorting the moving objects based on visible distance at every timestam reuires only O( P log P ) time, which is smaller than that of Nutanong et al. s algorithm. Therefore, we use the sorting based snashot VkNN uery algorithm instead of Nutanong et al. s algorithm as the baseline. However, this baseline solution still reuires too much communication and comutation costs incurred by soliciting location udates and sorting for all objects at every timestam. The need for a more efficient solution is evident. We roose a filtering-and-refinement framework to rocess the CVkNN uery on moving objects. The framework first erforms a two-stage filtering to reduce the search sace. Then refinement is erformed to examine the exact ositions of the unfiltered objects and find the uery result. As Figure 3 shows, we divide the time axis into eriods of T timestams each, where T is a system arameter. At the beginning of each eriod, we solicit location udates for all objects, which means that we only need to solicit location udates for all objects once every T timestams. We will analyze the effect of T on system erformance in Section 4.1 and erform an emirical study in Section 6.2. After the location udates are solicited, we build an R-tree on the moving objects (safe regions of the objects, actually). At every T timestams, T we udate the R-tree nodes according to the new locations of the objects. We use Previous T. Next T the R-tree to erform the first stage filtering, which results in a subset of P that is guaranteed. to contain all ossible VkNNs ε of the uery object for the next T timestams. We call this subset the candidate answer set and denote it by S c. During the Perform next T timestams, 1. Solicit we erform udate second-stage the second stage filtering on S c 2. Build an R-tree filtering and to determine the objects 3. Perform that firststage stage filtering is based on the visibility relationshi reuire torefinement be examined by refinement. This filtering between the object and no false dismissal will be introduced. We then sort the unfiltered objects based on their visible distance to the uery object to generate the exact uery result at each timestam. This rocess reeats and answers are reorted continuously for the CVkNN uery. T T 3.2. Query Processing Framework A straightforward solution to the CVkNN uery is to erform a snashot VkNN uery at every timestam as follows. At every timestam, we solicit location udates for all moving objects, sort the objects based on their visible distance to the uery object, and then reort the first k objects as the uery answer. This will serve as our baseline algorithm since there is no existing work on the CVkNN uery. We might use the solution roosed by Nutanong et al. [19] to rocess a snashot VkNN uery, but this solution is not efficient under our roblem settings for the following reason. Nutanong et al. assume an R-tree on the data objects and the obstacles, and then use a best-first traversal to identify the invisible regions and the uery object s nearest visible objects gradually. Alying their method means building an R-tree on the objects and the obstacles at every timestam, which has a time comlexity of O(( P + O ) log( P + O )). In our roblem settings, the obstacles are static. We just need to build an R-tree to index them once. 4. Perform second-stage filtering and refinement 1. Solicit location udates 2. Build an R-tree 3. Perform first-stage filtering. Figure 3: The uery rocessing framework Discussion. The advantage of our framework is that it only needs to solicit location udates for all objects every T timestams, while the snashot VkNN based solution reuires doing that at every timestam. A ossible concern is that our framework might have a high rocessing cost at the beginning of every eriod incurred by the three oerations, i.e., (i) soliciting location udates, (ii) building an R-tree, and (iii) filtering the search sace. We argue that these oerations are only erformed once every T timestams and hence the cost t

5 is amortized. Further, oerations (i) and (iii), soliciting location udates and filtering the search sace, are reuired for any algorithm that may efficiently rocess the CVkNN uery anyway. As for oeration (ii), building an in-memory R-tree is efficient [7, 29]. Our exerimental study shows that building an in-memory R-tree of size 10,000 takes only about 0.33 seconds. This small overhead enables effective R-tree based runing that significantly reduces the number of data objects to be checked in the refinement stage. Therefore, the cost of building an R- tree once every T timestams is justified. We also consider maintaining the R-tree incrementally, i.e., we build an R-tree at start and udate it as the objects move. The roblem of the incremental maintenance is that it has to rocess every object udate, which is too exensive when the objects udate freuently. As our exeriments show, rebuilding the R-tree is much more efficient than maintaining it incrementally under our settings. Processing multile ueries concurrently. When there are multile concurrent CVkNN ueries, we can rocess them together and reduce the rocessing costs by shared execution. In articular, in the first stage filtering, the R-tree on the moving objects is shared by multile CVkNN ueries to comute a candidate answer set for each uery, which can be done by a groued branch-and-bound search on the R-tree. This way we constrain the communication and comutation costs. In the second stage filtering, we examine each candidate answer set based on the visibility relationshi to obtain the VkNNs at each timestam. This filtering stage reuires soliciting the locations of some objects in the candidate answer sets. Since an object may belong to multile candidate answer sets, its solicited location can be shared by the filtering of multile candidate answer sets. This way we reduce the communication cost. throughout a eriod of T timestams. We call the suberiod when an object ( S c ) is invisible to the invisible time eriod of. Since an object s exact movement is not redictable, there is no way to comute an exact invisible time eriod. Instead, we comute a lower bound of the invisible time eriod of based on the current ositions of, and the obstacles between the two objects. Then during the bounded eriod, can be excluded from S c and need not to be examined in the refinement stage. When the bounded eriod exires, we solicit a location udate of and comute the next invisible time eriod lower bound for. This rocess reeats for the objects in S c. Since this makes some objects not be examined at every timestam, the cost of the refinement stage is reduced. To further imrove the runing caability of the invisible time eriod based method, we utilize the uery object s moving direction for the comutation of the invisible time eriod lower bound, which results in the moving direction aware invisible time eriod that is generally longer and always not shorter than the basic invisible time eriod lower bound. Next we elaborate the runing techniues Safe Region based Pruning We assume a global maximum seed of all objects, denoted by, which may be the greatest seed limit or the seed of the fastest object in a gaming/simulator system. Then during T timestams, the movement of an object must be within a circular region centered at with T being the radius. We call this circular region the safe region of (cf. Figure 4). 4. Pruning Techniues Our uery rocessing framework has two filtering stages. In the first filtering stage, the aim is to generate a set of uery answer candidates S c that can stay valid for the next T timestams while the size of the set is as small as ossible. In the second filtering stage, the aim is to further limit the number of objects in S c that need to be examined at each timestam by the refinement stage. Towards these aims, we roose a safe region based runing method and an invisible time eriod based runing method summarized as follows: Safe Region based Pruning. We use the safe region to define a region where a moving object must be in during a eriod of T timestams (cf. Section 4.1). Then for the uery object s safe region, we find its k th nearest data object s safe region that is entirely visible to it. The distance between these two safe regions defines a region where an object s safe region must intersect or be enclosed in so that this object can be in the uery answer candidate set S c. All other objects are runed from further rocessing. Invisible Time Period based Pruning. The objects in S c are close to the uery object but may not be visible to 5 safe regions 4 3 V(R ) o 3 6 P D o 1 1 o 2 5 I(R ) Figure 4: Safe region based runing (k = 2) MaxV D(R,R 5 ) MinV D(R,R 5 ) The Pruning Distances As objects safe regions bound their movement, objects whose safe regions are not close enough to the uery object s safe region can be discarded from the uery answer candidate set S c. We define three distances on the safe regions, which will then be used for the safe region based runing. We first extend the visible region of an object to the visible region of a region: the visible region of a region R, denoted by V(R), is defined as the intersection of the visible regions of all oints in R, i.e., a oint in V(R) is visible to every oint in R. Similarly, the invisible region of R, denoted by I(R), is defined as the union of the invisible regions of all oints in R. For examle, in Figure 4, the white region is the visible region

6 of R, V(R ), while the gray region is the invisible region of R, I(R ). By definition, if an object is in V(R ), it is guaranteed that the object will be visible to for the following T timestams. To comute V(R ), we draw tangent lines to R from the endoints of the obstacles in O. The tangent lines and the obstacles cli the invisible region from the data sace. The remaining region forms V(R ) (cf. Figure 4). Once we have V(R ), checking whether a region is (entirely) visible to R is done by checking whether the region is (fully) overlaed by V(R ). Now we can define the minimum visible distance, the maximum visible distance, and the runing distance. The minimum visible distance (MinVD) between R and a region R, denoted by MinVD(R, R), is defined as the smallest distance between a oint in R and a oint from R that is visible to R (i.e., in the visible region of R ). Formally, { MinDist(R, R V(R MinVD(R, R) = )) R is visible to R otherwise. Here, MinDist( ) is a function that returns the smallest distance between any two oints from two regions. Similarly, we define the maximum visible distance (MaxVD) between R and a region R, denoted by MaxVD(R, R), to be the largest distance between a oint in R and a oint from R that is visible to R. Formally, { MaxDist(R, R V(R MaxVD(R, R) = )) R is visible to R otherwise. Here, MaxDist( ) is a function that returns the largest distance between any two oints from two regions. The runing distance (PD) is then defined as the largest MaxVD of the k nearest safe regions who are entirely visible to R. Formally, PD = max{maxvd(r, R) R S R }, S R satisfies (i) S R = k (ii) R S R R S R, R V(R ) = R and R V(R ) = R MinVD(R, R) < MinVD(R, R ). The definition of PD guarantees that, during the following T timestams, we have k objects that are always visible to, while their distance to is at most PD. Any object whose safe region has a MinVD to R that is larger than PD cannot contribute to the uery answer candidate set S c (e.g., in Figure 4). Therefore, using PD for runing guarantees no false dismissal The Pruning Algorithm Safe region based runing works as follows. We solicit object location udates at the beginning of every eriod (i.e., every T timestams) and udate the R-tree T P. Then, we traverse T P in a best-first order to determine S c for the next T timestams. We start the traversal with inserting all entries of the root node of T P into a riority ueue Q P. The entries in Q P are rioritized based on their minimum visible distance to the safe region of the uery object, denoted by R. They are oed out one after another until Q P is emty. When an entry e os out, if 6 it is invisible to R, which means any oint bounded by e is invisible to every oint in R, then we simly discard the entry. Otherwise, (i) if e has a child node, then all entries in the child node are inserted into Q P ; (ii) if it is a data entry, which reresents the safe region of a data object, denoted by R, then we add to S c. We further check whether R is entirely visible to R, which means any oint in R is visible to every oint in R. If it is, then must be visible to and be a VkNN candidate throughout the next T timestams. We reeat the above rocess until we have found k data objects whose safe regions are entirely visible to R. These k objects guarantee that we have a candidate VkNN set for for the next T timestam eriod. We comute the runing distance PD to define a circular region and bound all these k objects safe regions. If there is an object whose safe region s minimum visible distance is larger than this runing distance, then cannot be closer to than any of these k objects. Therefore, any entry oed out from Q P whose minimum visible distance to R is larger than PD can be discarded from S c and hence we reduce the search sace. We summarize the runing algorithm in Algorithm 1, where T O denotes an R-tree that indexes the set of obstacles O to facilitate the comutation of visibility relationshis. Algorithm 1: Safe Region based Pruning Inut : R, T P, T O, k Outut: Candidate set S c 1 Initialize Q P with the entries in the root node of T P ; 2 PD, S c ; 3 while NOT Q P.emty() do 4 e Q P.o(); 5 if MinVD(R, e ) > PD then 6 break; 7 if e is visible to R then 8 if e has a child node then 9 Insert all entries in the child node of e into Q P ; 10 else 11 S c S c ; 12 if there are k objects in S c that are entirely visible to R then 13 Udate PD; Return S c. Figure 4 gives an examle to the above algorithm where we comute the CV2NN. We find 2 objects 5 and 6 whose safe regions are entirely visible to the safe region of. They must be in S c for the next T timestams. Between these two objects, 5 has a larger MaxVD value. Therefore, PD = MaxVD(R, R 5 ). Further, since the entries are rioritized in Q P based on MinVD, we can early terminate the algorithm once such an entry is oed out from Q P and thus reduce the comutation cost Choosing the Value of T The value of T significantly affects the system erformance. A larger T may reduce the cost of uery rocessing by reducing

7 the number of times that the R-tree is rebuilt. However, it will also increase the size of the safe regions and hence the number of candidate answers to be checked during the second filtering stage. Determining the best value of T theoretically is too difficult if ossible at all. It reuires an accurate model to redict the cost of a moving knn uery with the resence of obstacles and for real data distribution and movement atterns. A full study on such a detailed cost model is beyond the scoe of this study. Therefore, in our exerimental study, we choose the best value of T emirically in Section 6.2. In a moving object management system, the arameter T may be self-adjusted based on the statistics of the costs of rebuilding the R-tree and maintaining the candidate uery answer set. When the cost of rebuilding the R-tree dominates, the arameter T should be adjusted to a larger value to reduce the cost. Otherwise, the arameter T should be adjusted to a smaller value Invisible Time Period based Pruning After the safe region based runing, we have a set S c that contains the ossible VkNNs of the uery object for a eriod of T timestams. The set S c consists of two tyes of objects. Tye I includes objects whose safe regions are entirely visible to R - these objects determine the runing distance PD (cf. Figure 4, 5 and 6 ). Tye II includes objects whose safe regions are only artially visible to R but their minimum visible distance is smaller than PD (cf. Figure 4, 3 ). The latter tye has the otential of further reducing the search sace for VkNN comutation. Secifically, a Tye II object needs time to move to be visible to. We call this time the invisible time eriod of, denoted by τ. If we could comute the value of τ, we could exclude from S c until τ exires. Unfortunately, we cannot redict the exact movement of and thus, we cannot comute the exact value of τ. Instead, we comute a lower bound of τ that is guaranteed to exire before τ. Then we can exclude from S c until this lower bound exires, at which oint we solicit a location udate of and check if has actually became visible to. (i) If yes then we add it back to S c and continue with the regular refinement rocess. When becomes invisible to again, we recomute a lower bound of τ. (ii) Otherwise we directly recomute a lower bound of τ based on the udated location of. By this means, we further reduce the size of S c and hence reduce the uery rocessing costs. Next we exlore how to derive a lower bound of τ. We first derive a basic lower bound, denoted by τ l, and then refine it by taking the uery object s moving direction into consideration, which results in an imrove lower bound denoted by τ m A Lower Bound of the Invisible Time Period A lower bound estimation of τ, denoted by τ l, must guarantee that is invisible to within τ l, i.e., o, where o denotes an obstacle between and. A critical oint is when reaches an endoint of o, and the shortest time reuired for this to haen defines τ l. Figure 5(a) gives an examle, where needs to reach e 1 so that and can be visible to each other. Assume that and can both move at the global maximum seed towards arbitrary directions. We observe that, for 7 l e1 1 3 e 2 r e 1 o 3 1 (a) 2 l e1 1 3 Figure 5: Comutation of τ l 2 1 s e 2 e 1 r o 3 to reach an endoint of o with the shortest time, and should both move towards either a same endoint of o or a same direction that is erendicular to the line segment that connects the original locations of and, deending on which way results in the shortest moving time. For examle, in Figure 5(a), there are four choices of movement, i.e., { e 1, e 1 }, { e 2, e 2 }, { 1, 1 }, and {, 2 }, where denotes moves towards and 1,, 1 and 2 are all erendicular to. Then τ l is comuted as the smallest time that any of these choices reuires for to reach either e 1 or e 2. Formally, τ l = min{min{ e 1, e 1 }, min{ e 2, e 2 }, (b) max{ 1, 1 }, max{, 2 }}. Note that may have to cross o to get to 1 ( ) (cf. Figure 5(b)). In this case, needs to first get to an endoint e 1 (e 2 ). Therefore, we define 1 ( ) as the sum of e 1 ( e 2 ) and e 1 1 ( e 2 ). Similar definition alies to 1 ( 2 ) if 1 ( 2 ) intersects o. The following theorem guarantees the correctness of Euation 1 and hence no false dismissal will be introduced by this invisible time eriod lower bound based runing. Theorem 1. Given two oints and and a line segment e 1 e 2 such that intersects e 1 e 2 at r (r e 1, e 2 ), for and to move to two oints 1 and 1 so that 1 1 intersects e 1 e 2 at e 1 while max{ 1, 1 } is minimized, 1 and 1 should both be erendicular to if neither 1 nor 1 intersects e 1 e 2, otherwise 1 and 1 should be two oints such that 1 and 1 are overlaed by e 1 and e 1, resectively. Proof. First we rove that 1 and 1 should both be erendicular to if doing so does not result in either 1 or 1 intersecting e 1 e 2. Figure 5(a) illustrates how 1 and 1 are located in this case. Now assume that there are two oints and that and may move to so that intersects e 1. We rove max{ 1, 1 } max{, }. We denote the line that overlas as l e1. If l e1 also overlas 1 1, then max{ 1, 1 } max{, } is guaranteed by the fact that and 1 1 1, which means 1 ( 1 ) must be the shortest distance between () and a oint on l e1. Otherwise (l e1 does not overla 1 1 ), as shown in Figure 5(a), we let 3 and 3 be two oints on l e1 such that 3 l e1 and 3 l e1. (1)

8 Then by definition we have max{ 3, 3 } max{, }. We rove max{ 1, 1 } < max{, } through roving max{ 1, 1 } < max{ 3, 3 }. The latter ineuality is guaranteed by that 3 and 3 must be at different sides of 1 1 because otherwise either 3 or 3 must cross e 1 e 2. Meanwhile, and are both at the same side of 1 1. Therefore, either 3 or 3 must intersect 1 1. Without lost of generality we assume that 3 intersects 1 1. Then in triangle 3 1, we have 3 1 > 90 because 1 1 = 90. Thus, 3 is the longest side in the triangle and 3 > 1 = 1. Therefore, max{ 1, 1 } < max{ 3, 3 }. Next we rove that if and moving along the lines that are erendicular to the original will result in 1 or 1 intersecting e 1 e 2 before and are visible to each other, then 1 and 1 should change to two oints such that 1 and 1 are overlaed by e 1 and e 1, resectively. This effectively means that and should move to e 1 directly. Once either or reaches e 1, the line that connects them will intersect e 1 e 2 at e 1. Therefore, we need to rove min{ e 1, e 1 } < max{, }. Without lost of generality we assume that 1 intersects e 1 e 2 (note that 1 and 1 cannot both intersect e 1 e 2 ). Figure 5(b) illustrates the case, where l e1 is a line that overlas and 3 l e1, 3 l e1 at 3 and 3, resectively. We rove min{ e 1, e 1 } < max{, } through roving e 1 < max{ 3, 3 }. If e 1 < 3, then e 1 < max{ 3, 3 } holds. Otherwise, we rove e 1 < 3. We draw a line segment se 1 such that se 1 l e1 at e 1 and se 1 interests at s. Then e 1 < se 1 holds because in se 1, se 1 > s 1 = 90. Meanwhile, in traezoid e 1 s 3, se 1 < 3 because se 1 > 90 (derived from se 1 > 90 and se 1 < 90 ). Thus, we have e 1 < 3 and therefore, min{ e 1, e 1 } < max{, }. obtain a better lower bound of τ in this way. We call the resultant lower bound the moving direction aware invisible time eriod and denote it by τ m. e 3 o 2 e 4 l e3 e 1 o 1 e2 l e1 l e4 Figure 6: Comutation of τ l under multile obstacles Figure 7 shows an examle. When a lower bound of τ is to be comuted, we draw two lines l e1 and l e2 assing through the two endoints e 1 and e 2 of an obstacle o, and intersecting each other at. These two lines divide the movement of into four ranges D 1, D 2, D 3 and D 4. Each of these ranges is like a safe region for the moving direction of. As long as remains in the range where it is moving into at this instant (D 1 as in Figure 7), we can comute a larger lower bound of τ based on the osition relationshi between this range, the obstacle o and the moving object. This larger lower bound is the moving direction aware invisible time eriod τ m. If moves out of the range that it is currently moving into before τ m exires, then we can simly fall back to the lower bound τ l comuted by the method discussed in Section l e2 D 4 l e1 l e2 D 3 Until now we have considered only one obstacle between and. When there are multile obstacles, we just need to comute a lower bound of τ for each of the obstacles using Euation 1, and then choose the smallest one as the overall lower bound τ l. For examle, in Figure 6, we first comute two invisible time eriod lower bounds for based on e 1 e 2 and e 3 e 4, resectively. Then we can use the smaller one between the two lower bounds as the overall lower bound. The correctness of doing so is straightforward and hence the roof is omitted Moving Direction aware Invisible Time Period In this subsection we imrove the lower bound of the invisible time eriod by taking the uery object s movement into consideration. The intuition of this lower bound is that usually a moving object will not change its moving direction dramatically and hence it will stay in the range of its current moving direction for a while. Within this range, we can comute a shortest ath that can reach the visible region and hence an invisible time eriod lower bound. This shortest ath may not be the same as the overall shortest ath as comuted based on Theorem 1 in the last subsection, since the range moving into may not enclose the overall shortest ath. Thus, we can usually 8 D 1 D 2 e 2 e 1 o Figure 7: An examle of the moving ranges Next we illustrate how to comute τ m. Again we consider how and should move so that can meet one of the endoints e 1 and e 2 of the obstacle o as early as ossible, but now the movement of is constrained by the range it is moving into. Suose is moving into range D 1, as shown in Figure 7. We first consider how can meet e 1 early. Effectively this means how can reach the left boundary of the invisible region of, line l e1. An observation is that, for any oint in D 1, say, moving to will make l e1 rotate towards. We need to find the otimal ath for that makes l e1 rotate the fastest to meet, and the otimal ath for to reach l e1 accordingly. Meanwhile, moving to will make the right boundary of the invisible region of, line l e2, rotate away from. To let meet e 2 early, we need to find the otimal ath for that makes l e2 rotate the least and the otimal ath for to reach l e2 as early as ossible.

9 2 Next we describe how these otimal aths are comuted. Since l e1 and l e2 have different rotation directions for different moving ranges, we analyze the different cases of the four moving ranges searately and use Figure 8 for the illustration. D (d) (a) D 3 D 4 D 1 D 1 D 2 e 2 D 2 D 2 e 2 e 2 e 1 e 1 o e 1 o l e2 l e2 l e1 l e1 D 4 D 3 1 D 4 (b) (c) 1 2 D 3 1 D 3 D 1 D 1 D 1 D 2 D 2 D 2 e 2 e e 2 e 2 1 o e 1 o e 1 o 1 1 l e2 1 l e2 l e2 D l e2 4 l e1 l e1 l e1 D 4 D 43 (c) (d) (b) D 41 D 3 Figure 8: Comutation of τ m D 1 D 3 D D 1 2 As shown in Figure 8(a), if is moving towards D 1, then l e1 D 2 will rotate towards while l e2 will rotate away from. We l l 2 1 o e 2 e 1 describe how can reach l e1 and l e2 early as follows. (i) For to reach l e1 early, and should both follow the movement as described in the last subsection, i.e., both and move in the direction that is erendicular to the current, and if in this way or reaches o before reaches e 1, then both and should move directly to e 1. (ii) For to reach l e2 early, since moving into D 1 will result in l e2 rotating away from, the best can do is to move along the current l e2 (or do not move at all) so that l e2 does not rotate away any farther. Meanwhile, should move erendicularly towards l e2 since this is the shortest ath that a oint can reach a line. If in this way reaches o before reaches e 2, then should move directly to e 2. The shortest time that and needs to move as described above before reaches either e 1 or e 2 (i.e., reaches either l e1 or l e2 ) defines τ m. If is moving towards D 2, as shown in Figure 8(b), both l e1 and l e2 are rotating away from. Therefore, for to reach either line early, should move along l e1 (l e2 ) towards e 1 (e 2 ) to kee l e1 (l e2 ) from rotating away, while should move erendicularly towards l e1 (l e2 ). If in this way reaches o before reaches e 1 (e 2 ), then should move directly to e 1 (e 2 ). If is moving towards D 3, as shown in Figure 8(c), the situation is very similar to that of moving towards D 1. Therefore, the analysis of that revious case (i.e., moving towards D 1 ) alies. The only difference is that now l e1 is rotating away from while l e2 is rotating towards. If is moving towards D 4, as shown in Figure 8(d), both l e1 and l e2 are rotating towards. In this case, needs to move 9 along the current l e2 (l e1 ) so that l e1 (l e2 ) can rotate the fastest towards. To determine the shortest distance and need to move until intersects e 1, we let 1 be a oint on l e2 and 1 1 be a line segment that intersects e 1 and is erendicular to 1. When 1 = 1, the two line segments 1 and 1 are the shortest aths for to reach e 1. The correctness of this claim can be roved in a way that is similar to the roof of Theorem 1 and thus the roof is omitted. Intuitively, among all line segments in D 4 that have the same length as 1, 1 has the longest rojection on the overall best ath of to make reach e 1 (i.e., 1 in Figure 8(a)). Meanwhile, we have established in Theorem 1 that 1 and 1 should be of the same length so that max{ 1, 1 } is minimized. Therefore, the aths 1 and 1 described above are the otimal aths. By basic geometry we comute the locations of 1 and 1 and get 1 and 1. Again if cannot reach 1 without crossing o then should D 4 move directly to D 3 e 1. Similarly we get the otimal aths and 2 for to reach e 2 early. The correctness of the above analysis is suorted by Theorem 1. We still use Euation 1 to comute τ m, but the oints reresented by 1 and in the euation are changed to the oints described above for the four cases accordingly. l e1 l e2 Figure 9: Another choice of data sace artitioning Discussion. Using l e1 and l e2 is not the only way to divide the sace. We have chosen these two lines because every resultant range has one unchanged rotation direction for each of the invisible region sides. This leads to a simle and efficient way to comute a lower bound of τ. We might use other lines to artition the sace and comute lower bounds of τ based on those lines, but then some of the resultant ranges may overla more than one of the ranges as divided by l e1 and l e2, and the comutation of a lower bound of τ will become comlicated and less efficient. For examle, as shown in Figure 9, we use two lines l 1 and l 2 to divide the sace and denote the resultant ranges by D 1, D 2, D 3 and D 4. We can see that D 4 overlas D 1, D 3 and D 4. The overlaing ranges are D 41, D 43 and D 4, resectively. Then, we have to comute lower bounds of τ for each of these ranges and then find the smallest as the the lower bound of τ for range D 4, which is more comlex than using l e1 and l e2 directly. 5. Cost Analysis In this section we analyze the erformance of the roosed runing methods and comare the roosed framework with the

10 snashot VkNN based method in communication and comutation costs. For simlicity, we denote the snashot VkNN based method, the safe region based runing method, the basic lower bound invisible time eriod based runing method and the moving direction aware invisible time eriod based runing method as SV, SR, LITP and MITP, resectively Communication Cost In a client-server based uery rocessing system, the communication cost is caused by two oerations, i.e., soliciting location udates from the moving objects (clients) and reorting the uery result to the uery object. In a centralized system, the communication cost is relaced by the cost of accessing the object location data within the centralized system and reorting the uery result to itself for later use. Since the cost of reorting the uery result is the same for all CVkNN uery rocessing methods, and it is much smaller than the cost of getting the location udates, we focus on the cost of getting the location udates. We comare for the various methods the number of location udates solicited during a eriod of T timestams starting from the beginning of the eriod. A) SV needs the exact location for each moving object (including the uery object) at each timestam. Therefore, its communication cost for T timestams, denoted as CM S V, is comuted as: CM S V = ( P + 1)T = ( P + 1) + ( P + 1)(T 1). (2) B) Our roosed framework first erforms safe region based runing using the locations of all objects, which results in a subset S c of P as the uery answer candidate set for the next T timestams (including the current timestam). Then invisible time eriod based runing is erformed to further reduce the number of objects in S c to be checked by the refinement ste to generate the exact uery answer set at each timestam. B.i) If only SR is alied, then the communication cost of the roosed framework, denoted by CM S R, is comuted as: CM S R = ( P + 1) + ( S c + 1)(T 1) (3) By comaring Euations 2 and 3, we can see that CM S R CM S V is guaranteed since S c P. The sueriority of the roosed framework over SV deends on S c P, which in turn deends on T because T determines the sizes of the safe regions and the runing distance. To learn the effect of T, we look at the average er timestam communication cost of SR, denoted as CM S R and derived from Euation 3 as follows. CM S R = ( P + 1) + ( S c + 1)(T 1) T = P \ S c + ( S c + 1) + ( S c + 1)(T 1) T = P \ S c + S c + 1 T When T increases, the denominator in the euation increases. However, S c also becomes larger because the size of the safe (4) 10 regions increases and so as the runing distance. There is no obvious theoretical trend on the combined effect and we will use exeriments to find a suitable value of T to otimize the erformance of the roosed framework. We let ω S R be S c P and use it to denote the runing ower of SR. Then CM S R becomes ( P + 1) + (ω S R P + 1)(T 1). When the invisible time eriod based runing is also alied, the size of S c is further reduced. B.ii) The communication cost of the roosed framework when alying SR + LITP and SR + MITP, denoted as CM S L and CM S M resectively, are comuted as follows. CM S L = ( P + 1) + (ω S L P + 1)(T 1) (5) CM S M = ( P + 1) + (ω S M P + 1)(T 1) (6) Here, ω S L and ω S M denote the runing ower of SR in combined with LITP and MITP, resectively. The runing ower deends on whether LITP or MITP can kee more objects from S c. By definition, MITP comutes invisible time eriod lower bounds that are at least as long as what LITP comutes. Thus, its runing ower is at least as good as that of LITP, i.e., ω S M ω S L. Therefore, SR+MITP erforms no worse than SR+LITP in terms of communication cost Comutation Cost For comutation cost analysis we also consider the cost of a eriod of T timestams. A) SV comutes the visible distance and erforms a sorting for all objects at each timestam. The comutation cost, denoted as CP S V, is comuted as: CP S V = ϕ S V P T = ϕ S V P + ϕ S V P (T 1), (7) where ϕ S V denotes the scaling of the cost of visible distance comutation and sorting on P. B) Our roosed framework s comutation cost consists of three tyes of costs: (i) the cost of safe region based runing, denoted as CP S R, which involves building an in-memory R-tree and a best-first traversal on the tree, (ii) the cost of invisible time based runing, denoted as CP LP and CP MP for LITP and MITP, resectively, which involves invisible time eriod comutation and checking whether the objects in S c are in their invisible time eriods, and (iii) the cost of refinement, denoted as CP RF, which involves comuting the exact distance between the uery object and the objects in S c and sorting to determine the uery answer set. While CP S R is reuired only at the first timestam, CP LP (CP MP ) and CP RF are both reuired at every timestam. We denote the comutation cost for SR + LITP and SR + MITP as CP S L and CP S M, resectively. Then we have: CP S L = CP S R + (CP LP + CP RF )T = CP S R + CP LP + CP RF + (CP LP + CP RF )(T 1) (8) CP S M = CP S R + (CP MP + CP RF )T = CP S R + CP MP + CP RF + (CP MP + CP RF )(T 1) (9)