Incremental nearest-neighbor search in moving objects
Apostolos Papadopoulos2005, ICPS '05. Proceedings. International Conference on Pervasive Services, 2005.
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
In databases of moving objects it is important to answer queries that concern the future positions of the objects. An important query type in such an environment is the nearest-neighbor query, which asks for the k closest objects of a query object during a time interval [t s , t e ]. However, there are cases where the (k+1)-th nearest-neighbor is requested after the execution of the k-NN query. In such a case, either the query must be evaluated again, or we can exploit the previous result and use an incremental method to determine the new answer. We focus on the second alternative and present efficient incremental algorithms that outperform the trivial method which is based on complete re-execution of the query. In addition, we study the problem of keeping the query result consistent in the presence of object insertions, deletions and updates which are very common in a dynamic moving-object environment.
Related papers
Fast nearest-neighbor query processing in moving-object databases
GeoInformatica, 2003
A desirable feature in spatio-temporal databases is the ability to answer future queries, based on the current data characteristics (reference position and velocity vector). Given a moving query and a set of moving objects, a future query asks for the set of objects that satisfy the query in a given time interval. The difficulty in such a case is that both the query and the data objects change positions continuously, and therefore we can not rely on a given fixed reference position to determine the answer. Existing techniques are either ...
Nearest and reverse nearest neighbor queries for moving objects
The VLDB Journal, 2006
With the continued proliferation of wireless communications and advances in positioning technologies, algorithms for efficiently answering queries about large populations of moving objects are gaining interest. This paper proposes algorithms for k nearest and reverse k nearest neighbor queries on the current and anticipated future positions of points moving continuously in the plane. The former type of query returns k objects nearest to a query object for each time point during a time interval, while the latter returns the objects that have a specified query object as one of their k closest neighbors, again for each time point during a time interval. In addition, algorithms for so-called persistent and continuous variants of these queries are provided. The algorithms are based on the indexing of object positions represented as linear functions of time. The results of empirical performance experiments are reported.
Nearest neighbor and reverse nearest neighbor queries for moving objects
Proceedings International Database Engineering and Applications Symposium, 2002
With the proliferation of wireless communications and the rapid advances in technologies for tracking the positions of continuously moving objects, algorithms for efficiently answering queries about large numbers of moving objects increasingly are needed. One such query is the reverse nearest neighbor (RNN) query that returns the objects that have a query object as their closest object. While algorithms have been proposed that compute RNN queries for non-moving objects, there have been no proposals for answering RNN queries for continuously moving objects. Another such query is the nearest neighbor (NN) query, which has been studied extensively and in many contexts. Like the RNN query, the NN query has not been explored for moving query and data points. This paper proposes an algorithm for answering RNN queries for continuously moving points in the plane. As a part of the solution to this problem and as a separate contribution, an algorithm for answering NN queries for continuously moving points is also proposed. The results of performance experiments are reported.
On moving object queries
Proceedings of the twenty-first ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems - PODS '02, 2002
Database applications for moving objects pose new challenges in modeling, querying, and maintenance of objects whose locations are rapidly changing over time. Previous work on modeling and querying spatio-temporal databases and constraint databases focus primarily on snapshots of changing databases. In this paper we study query evaluation techniques for moving object databases where moving objects are being updated frequently. We consider a constraint database approach to moving objects and queries. We classify moving object queries into: "past", "continuing", and "future" queries. We argue that while traditional constraint query evaluation techniques are suitable for past queries, new techniques are needed for continuing and future queries. Motivated by nearest-neighbor queries, we define a query language based on a single "generalized distance" function f mapping from objects to continuous functions from time to R. Queries in this language may be past, continuing, or future. We show that if f maps to polynomials, queries can be evaluated efficiently using the plane sweeping technique from computational geometry. Consequently, many known distance based queries can be evaluated efficiently.
Continuous aggregate nearest neighbor queries
GeoInformatica, 2013
This paper addresses the problem of continuous aggregate nearest-neighbor (CANN) queries for moving objects in spatio-temporal data stream management systems. A CANN query specifies a set of landmarks, an integer k, and an aggregate distance function f (e.g., min, max, or sum), where f computes the aggregate distance between a moving object and each of the landmarks. The answer to this continuous query is the set of k moving objects that have the smallest aggregate distance f . A CANN query may also be viewed as a combined set of nearest neighbor queries. We introduce several algorithms to continuously and incrementally answer CANN queries. Extensive experimentation shows that the proposed operators outperform the state-ofthe-art algorithms by up to a factor of 3 and incur low memory overhead.
Indexing the positions of continuously moving objects
ACM Sigmod …
The coming years will witness dramatic advances in wireless communications as well as positioning technologies. As a result, tracking the changing positions of objects capable of continuous movement is becoming increasingly feasible and necessary. The present paper proposes a novel, R £-tree based indexing technique that supports the efficient querying of the current and projected future positions of such moving objects. The technique is capable of indexing objects moving in one-, two-, and three-dimensional space. Update algorithms enable the index to accommodate a dynamic data set, where objects may appear and disappear, and where changes occur in the anticipated positions of existing objects. A comprehensive performance study is reported.
Q+Rtree: efficient indexing for moving object databases
Eighth International Conference on Database Systems for Advanced Applications, 2003. (DASFAA 2003). Proceedings., 2003
Moving object environments contain large numbers of queries and continuously moving objects. Traditional spatial index structures do not work well in this environment because of the need to frequently update the index which results in very poor performance. In this paper, we present a novel indexing structure, namely the Q+Rtree, based on the observation that i) most moving objects are in quasi-static state most of time, and ii) the moving patterns of objects are strongly related to the topography of the space. The Q+Rtree is a hybrid tree structure which consists of both an R-tree and a QuadTree. The Rtree component indexes quasi-static objects-those that are currently moving slowly and are often crowded together in buildings or houses. The Quadtree component indexes fast moving objects which are dispersed over wider regions. We also present the experimental evaluation of our approach.
Efficiently processing snapshot and continuous reverse k nearest neighbors queries
The VLDB Journal, 2012
Given a set of objects and a query , a point is called the reverse nearest neighbor (R NN) of if is one of the closest objects of. In this paper, we introduce the concept of influence zone which is the area such that every point inside this area is the R NN of and every point outside this area is not the R NN. The influence zone has several applications in location based services, marketing and decision support systems. It can also be used to efficiently process R NN queries. First, we present efficient algorithm to compute the influence zone. Then, based on the influence zone, we present efficient algorithms to process R NN queries that significantly outperform existing best known techniques for both the snapshot and continuous R NN queries. We also present a detailed theoretical analysis to analyse the area of the influence zone and IO costs of our R NN processing algorithms. Our experiments demonstrate the accuracy of our theoretical analysis. This paper is an extended version of our previous work [9]. We make the following new contributions in this extended version: 1) we conduct a rigorous complexity analysis and show that the complexity of one of our proposed algorithms in [9] can be reduced from (2) to () where > is the number of objects used to compute the influence zone ; 2) we show that our techniques can
Complex Queries for Moving Object Databases in DHT-Based Systems
2008
Distributed moving object database servers are a feasible solution to the scalability problem of centralized database systems. In this paper we propose a distributed indexing method, using the Distributed Hash Table (DHT) paradigm, devised to efficiently support complex spatio temporal queries. We assume a setting in which there is a large number of database servers that keep track of events associated with a highly dynamic system of moving objects deployed in a spatial area. We present a technique for properly keeping the index up to date and efficiently processing range and top-k queries for moving object databases. We evaluated our system using event-driven simulators with demanding spatio temporal workloads and the results show good performance in terms of response time and network traffic.
Efficient update method for indexing locations of moving objects
2005
Tracking the changing positions of moving objects is becoming increasingly feasible and necessary. However, traditional spatial index structures are not suitable for storing these positions because of numerous update operations. In this paper, we propose an efficient update method for indexing the locations of moving objects based on the R-tree. This technique updates the structure of the index only when an object moves out of the corresponding MBR (minimum bounding rectangle). If a new position of an object is in the MBR, it changes the leaf node only. Using a secondary access path to find the corresponding leaf node, the proposed technique can update the position of the object quickly and reduce update the cost greatly. In addition, our technique can be adopted in diverse variants of the R-tree and various applications that use the R-tree since it is based on the R-tree and it guarantees the correctness of the R-tree. We also present experimental results which show that our technique outperforms other techniques.
Related papers
Algorithms for Nearest Neighbor Search on Moving Object Trajectories
GeoInformatica, 2007
Nearest Neighbor (NN) search has been in the core of spatial and spatiotemporal database research during the last decade. The literature on NN query processing algorithms so far deals with either stationary or moving query points over static datasets or future (predicted) locations over a set of continuously moving points. With the increasing number of Mobile Location Services (MLS), the need for effective k-NN query processing over historical trajectory data has become the vehicle for data analysis, thus improving existing or even proposing new services.
Nearest Neighbor Search on Moving Object Trajectories
Lecture Notes in Computer Science, 2005
Nearest Neighbor (NN) search has been in the core of spatial and spatiotemporal database research during the last decade. The literature on NN query processing algorithms so far deals with either stationary or moving query points over static datasets or future (predicted) locations over a set of continuously moving points. With the increasing number of Mobile Location Services (MLS), the need for effective k-NN query processing over historical trajectory data has become the vehicle for data analysis, thus improving existing or even proposing new services.
Close pair queries in moving object databases
Proceedings of the 2005 international workshop on Geographic information systems - GIS '05, 2005
Databases of moving objects are important for air traffic control, ground traffic, and battlefield configurations. We introduce the (historical and spatial) range close-pair query for moving objects as an important problem for such databases. The purpose of a range close-pair query for moving objects is to find pairs of objects that were closer than during time interval I and within spatial range R, where , I and R are user-specified parameters. This paper solves the range close-pair query using two components: the retrieval component and the close-pair identification component. The retrieval component breaks up long trajectories into trajectory segments, which are produced in increasing time order, without the need for sorting. The retrieval component takes advantage of a new index mechanism, the Multiple TSB-tree. The segments are then pipelined to the close-pair identification component. The identification component introduces a novel spatial sweep that sweeps by time and one spatial dimension at the same time. Extensive experimental results are provided, demonstrating the advantages of the new approach when considering close pairs.
An Indexing Method for Answering Queries on Moving Objects
Distributed and Parallel Databases, 2005
We consider the problem of indexing a set of objects moving in d-dimensional spaces along linear trajectories. A simple external-memory indexing scheme is proposed to efficiently answer general range queries. The following are examples of the queries that can be answered by the proposed method: report all moving objects that will (i) pass between two given points within a specified time interval; (ii) become within a given distance from some or all of a given set of other moving objects. Our scheme is based on mapping the objects to a dual space, where queries about moving objects are transformed into polyhedral queries concerning their speeds and initial locations. We then present a simple method for answering such polyhedral queries, based on partitioning the space into disjoint regions and using a B+-tree to index the points in each region. By appropriately selecting the boundaries of each region, we guarantee an average search time that matches a known lower bound for the problem. Specifically, for a fixed d, if the coordinates of a given set of N points are statistically independent, the proposed technique answers polyhedral queries, on the average, in
Motion Adaptive Indexing for Moving Continual Queries over Moving Objects
This paper describes a motion adaptive indexing scheme for efficient evaluation of moving continual queries (MCQs) over moving objects. It uses the concept of motion-sensitive bounding boxes (MSBs) to model moving objects and moving queries. These bounding boxes automatically adapt their sizes to the dynamic motion behaviors of individual objects. Instead of indexing frequently changing object positions, we index less frequently changing object and query MSBs, where updates to the bounding boxes are needed only when objects and queries move across the boundaries of their boxes. This helps decrease the number of updates to the indexes. More importantly, we use predictive query results to optimistically precalculate query results, decreasing the number of searches on the indexes. Motion-sensitive bounding boxes are used to incrementally update the predictive query results. Our experiments show that the proposed motion adaptive indexing scheme is efficient for the evaluation of moving continual range queries.
Scalable Distributed Processing of K Nearest Neighbor Queries over Moving Objects
IEEE Transactions on Knowledge and Data Engineering, 2015
Central to many applications involving moving objects is the task of processing k-nearest neighbor (k-NN) queries. Most of the existing approaches to this problem are designed for the centralized setting where query processing takes place on a single server; it is difficult, if not impossible, for them to scale to a distributed setting to handle the vast volume of data and concurrent queries that are increasingly common in those applications. To address this problem, we propose a suite of solutions that can support scalable distributed processing of k-NN queries. We first present a new index structure called Dynamic Strip Index (DSI), which can better adapt to different data distributions than exiting grid indexes. Moreover, it can be naturally distributed across the cluster, therefore lending itself well to distributed processing. We further propose a distributed k-NN search (DKNN) algorithm based on DSI. DKNN avoids having an uncertain number of potentially expensive iterations, and is thus more efficient and more predictable than existing approaches. DSI and DKNN are implemented on Apache S4, an open-source platform for distributed stream processing. We perform extensive experiments to study the characteristics of DSI and DKNN, and compare them with three baseline methods. Experimental results show that our proposal scales well and significantly outperforms the alternative methods.
An efficient location update mechanism for continuous queries over moving objects
Information Systems, 2007
In a moving-object database system that supports continuous queries (CQ), an important problem is to keep the location data consistent with the actual locations of the entities being monitored, in order to produce correct query results. This goal is often difficult to achieve due to limited network resources. However, if an object is not required by any query, its value need not be refreshed. Based on this observation, we redefine the notion of temporal consistency of data items with respect to the query result, where only data items that are relevant to the CQs need to be fresh. To exploit this correctness definition, we develop an adaptive time-based update technique called Query-Result Update (QRU). The advantage of this technique is that it identifies objects with different levels of significance to the correctness of query results. Locations of objects that have more impact to the query result are acquired more frequently than the ones that do not. To achieve this objective, queries are classified into rank-based (i.e., ranks of objects are critical to query results) and non-rank-based. For each query class, QRU decides the time instant that an object should send a location update based on the predicted impact of the object to the query result. Moreover, the location update frequency of each object is continuously adjusted in order to adapt to the accuracy of the prediction model used. We evaluate the effectiveness of QRU by simulating execution of CQs over synthetic and real data sets. We also compare QRU experimentally with existing location update policies, namely the distance-based method, the time-based method, the speed dead-reckoning method, as well as the safe region strategy.
Approximate Direct and Reverse Nearest Neighbor Queries, and the k-nearest Neighbor Graph
2009 Second International Workshop on Similarity Search and Applications, 2009
Retrieving the k-nearest neighbors of a query object is a basic primitive in similarity searching. A related, far less explored primitive is to obtain the dataset elements which would have the query object within their own k-nearest neighbors, known as the reverse k-nearest neighbor query. We already have indices and algorithms to solve k-nearest neighbors queries in general metric spaces; yet, in many cases of practical interest they degenerate to sequential scanning. The naive algorithm for reverse k-nearest neighbor queries has quadratic complexity, because the k-nearest neighbors of all the dataset objects must be found; this is too expensive. Hence, when solving these primitives we can tolerate trading correctness in the solution for searching time. In this paper we propose an efficient approximate approach to solve these similarity queries with high retrieval rate. Then, we show how to use our approximate k-nearest neighbor queries to construct (an approximation of) the k-nearest neighbor graph when we have a fixed dataset. Finally, combining both primitives we show how to dynamically maintain the approximate k-nearest neighbor graph of the objects currently stored within the metric dataset, that is, considering both object insertions and deletions.
Querying imprecise data in moving object environments
IEEE Transactions on Knowledge and Data Engineering, 2004
In moving object environments it is infeasible for the database tracking the movement of objects to store the exact locations of objects at all times. Typically the location of an object is known with certainty only at the time of the update. The uncertainty in its location increases until the next update. In this environment, it is possible for queries to produce incorrect results based upon old data. However, if the degree of uncertainty is controlled, then the error of the answers to queries can be reduced. More generally, query answers can be augmented with probabilistic estimates of the validity of the answer. In this paper we study the execution of probabilistic range and nearest-neighbor queries. The imprecision in answers to queries is an inherent property of these applications due to uncertainty in data, unlike the techniques for approximate nearest-neighbor processing that trade accuracy for performance. Algorithms for computing these queries are presented for a generic object movement model, and detailed solutions are discussed for two common models of uncertainty in moving object databases. We also study approximate evaluation of these queries to reduce their computation time.
Efficient Tradeoff Schemes in Data Structures for Querying Moving Objects
Lecture Notes in Computer Science, 2004
The ability to represent and query continuously moving objects is important in many applications of spatio-temporal database systems. In this paper we develop data structures for answering various queries on moving objects, including range and proximity queries, and study tradeoffs between various performance measures-query time, data structure size, and accuracy of results.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.