Extract and Maintain the Most Helpful Wavelet Coefficients for Continuous K-Nearest Neighbor Queries in Stream Processing

Recently more and more people focus on continuous K-Nearest Neighbor (CKNN) query processing over moving Objects in Road Networks. A CKNN query is to find among all moving objects the K-nearest neighbors (KNNs) of a moving query object during a period of time. The main issue with existing methods is that moving objects change their locations frequently over time and if their location updates cannot be processed in time, the system runs the risk of retrieving the incorrect results of KNN. In this paper, an effective method is proposed to deal with continuous K-Nearest Neighbor query processing. By considering whether a moving object o is moving farther away from or getting closer to a query point q, the object which is definitely not in the KNN result set is effectively excluded. Thus we can reduce the communication cost, meanwhile we can also simplify the network distance computation between moving objects and query q. Comprehensive experiments are conducted and the results verify the effectiveness of the proposed algorithms.

One of the most important queries in spatio-temporal databases that aim at managing moving objects efficiently is the continuous K-nearest neighbor (CKNN) query. A CKNN query is to retrieve the K-nearest neighbors (KNNs) of a moving user at each time instant within a user-given time interval [t s , t e ]. In this paper, we investigate how to process a CKNN query efficiently. Different from the previous related works, our work relieves the past assumption, that an object moves with a fixed velocity, by allowing that the velocity of the object can vary within a known range. Due to the introduction of this uncertainty on the velocity of each object, processing a CKNN query becomes much more complicated. We will discuss the complications incurred by this uncertainty and propose a cost-effective P2 KNN algorithm to find the objects that could be the KNNs at each time instant within the given query time interval. Besides, a probability-based model is designed to quantify the possibility of each object being one of the KNNs. Comprehensive experiments demonstrate the efficiency and the effectiveness of the proposed approach.

The continuous K nearest neighbor (CKNN) query is an important type of query that finds continuously the KNN to a query point on a given path. We focus on moving queries issued on stationary objects in Spatial Network Database (SNDB) The result of this type of query is a set of intervals (defined by split points) and their corresponding KNNs. This means that the KNN of an object traveling on one interval of the path remains the same all through that interval, until it reaches a split point where its KNNs change. Existing methods for CKNN are based on Euclidean distances. In this paper we propose a new algorithm for answering CKNN in SNDB where the important measure for the shortest path is network distances rather than Euclidean distances. We propose DAR and eDAR algorithms to address CKNN queries based on the progressive incremental network expansion (PINE) technique. Our experiments show that the eDAR approach has better response time, and requires fewer shortest distance computations and KNN queries than approaches that are based on VN3 using IE.

A collaborative approach to moving [formula omitted]-nearest neighbor queries in directed and dynamic road networks

In this paper, two strategies for processing a continuous k-nearest neighbor query for location-based services are proposed. Both use a spatial access method, the mqrtree, for locating a safe region. The mqrtree supports searching within the structure, so searches from the root are not required - a property which is exploited in the strategies. However, the proposed strategies will work with most spatial access methods. The strategies are evaluated and compared against a repeated nearest neighbor search. It is shown that both approaches achieve significant performance gains in reducing the number of times a new safe region must be identified, in both random and exponentially distributed points sets.

In this paper we propose a strategy for continuous k-nearest neighbour query processing for location-based services. Our approach applies clustering, which has not been applied to k-nearest neighbour processing by other works. Using a clustered point set on the server, a safe region is formed using a subset of the existing clusters. As long as the user's location (i.e., query point) remains in the safe region, the data set on the server can be used to accurately answer all k-nearest neighbour queries the majority of the time. Our strategy is an approximation strategy, as there are situations where the result produced for the user may not be accurate. However, an evaluation of our strategy show that the result is accurate at least 70% of the time in most cases. We also observed that when compared to repeated k-nearest neighbour search, our strategy is computationally significantly faster for a larger dataset. Therefore, it is worth the trade-off of less than 100% accuracy to achieve results quickly, and for several applications (e.g., restaurant searching), this can be ideal.

The extreme volume and staggeringly increasing rate inevitably produce unprecedented pressure on any large scale video sharing and hosting systems. Among the efforts to mitigate this pressure, content-based video similarity search is becoming more and more important with the exponential growth of the data size. Though various approaches have been proposed to address this problem, they are mainly focusing on the retrieval accuracy thus bringing video features with high complexity. Due to the complexity of the feature, these systems are based on the assumption that features representing videos have been obtained offline and stored in the database statically. However, the on-call efforts to move the feature extraction and similarity search from offline to online have been ignored in previous work. In this paper, we propose Marlin, a streaming data processing pipeline that efficiently extracts video features and retrieves video similarity information in a large scale video data system. We design a streaming feature extractor to handle the videos streaming into the system and establish the fined-grained resource allocation with a resource-aware data abstraction layer over streaming data to allocate computing resources among the videos with various resource demands. Besides that, we are pipelining the feature extraction and similarity search process with a distributed feature index, which supports real-time query and incremental index update. The experimental and the extensive real-world workload driven simulation results show that the proposed stream processing architecture achieves 25X speedup against the sequential feature extraction algorithm and 23X speedup against the sequential similarity search with a subsecond similarity query latency for a single request.

Reverse k-nearest neighbor (RkNN) queries are prevalent in location-based services to find those locations that have the query point as one of their k nearest neighbors. However, such query requires users to disclose the location of the query point to a service provider who might be untrustworthy. Previous attempts to preserve the privacy of RkNN queries are either based on weaker notions of privacy such as location cloaking or not efficient when k > 1. In this paper, we propose novel solutions based on the private information retrieval (PIR) mechanism to preserve the privacy of RkNN query points. Our solutions include server-side data indexing and client-side query processing methods to facilitate PIR which is an inherently expensive data retrieval mechanism. We experimentally evaluate our approach using real-world datasets and show that it preserves the location privacy of queries with reasonable computation and storage overhead.

Metric Access Methods (MAM) are employed to accelerate the processing of similarity queries, such as the range and the k-nearest neighbor queries. Current methods, such as the Slim-tree and the M-tree, improve the query performance minimizing the number of disk accesses, keeping a constant height of the structures stored on disks (height-balanced trees). However, the overlapping between their nodes has a very high influence on their performance. This paper presents a new dynamic MAM called theDBM-tree (Density-Based Metric tree), which can minimize the overlap between high-density nodes by relaxing the height-balancing of the structure. Thus, the height of the tree is larger in denser regions, in order to keep a tradeoff between breadth-searching and depth-searching. An underpinning for cost estimation on tree structures is their height, so we show a non-height dependable cost model that can be applied for DBM-tree. Moreover, an optimization algorithm calledShrink is also presented, which improves the performance of an already builtDBM-tree by reorganizing the elements among their nodes. Experiments performed over both synthetic and real world datasets showed that theDBM-tree is, in average, 50% faster than traditional MAM and reduces the number of distance calculations by up to 72% and disk accesses by up to 66%. After performing the Shrink algorithm, the performance improves up to 40% regarding the number of disk accesses for range andk-nearest neighbor queries. In addition, theDBM-tree scales up well, exhibiting linear performance with growing number of elements in the database.

Reverse k-Nearest Neighbor (RkNN) Queries have got considerable attentions over the recent years. Most state of the art methods use the two-step (filter-refinement) RkNN processing. However, for a large k, the amount of calculation becomes very heavy, especially in the filter step. This is not acceptable for most mobile devices. A new filter strategy called BRC is proposed to deal with the filter step for RkNN queries. There are two pruning heuristics in BRC. The experiments show that the processing time of BRC is still acceptable for most mobile devices when k is large. And we extend the BRC to the continuous RkNN queries.KeywordsReverse k-Nearest NeighborContinuous Reverse k-Nearest NeighborSpatial Database

iSurveillance: Intelligent framework for multiple events detection in surveillance videos

Intensive study has been dedicated to wireless sensor networks and their applications in the last few years. However, similarity search problem in sensor network environments seems to have not attracted the deserved attention. In fact, sensor detected data are very likely imprecise due to the simplified hardware of the sensor itself and various environmental factors. Hence, queries requesting for similar result should be an often scenario and an important problem to resolve. In this paper, we propose a similarity search algorithm (SSA) for efficiently processing similarity search queries. We first present a data-centric storage structure based on the concept of Hilbert curve. Then, we propose an algorithm designed for efficiently probing the most similar data item for the sensor network. The performance study reveals that this mechanism is highly efficient and significantly outperforms other approaches in processing similarity search queries.

Stream processing has evolved as a paradigm for efficiently sharing and integrating a massive amount of data into applications. However, the integration of globally dispersed sensor data imposes challenges in the effective utilization of the IT infrastructure that forms the global sensor network. Especially simulations require the integration of sensor streams at widely differing spatial and temporal resolutions. For current stream processing solutions it is necessary to generate a separate data stream for each requested resolution. Therefore, these systems suffer from high redundancy in data streams, wasting a significant amount of bandwidth and limiting their scalability.This paper presents a new approach to scalable distributed stream processing of data which stems from globally dispersed sensor networks. The approach supports applications in establishing continuous queries for sensor data at different resolutions and ensures efficient bandwidth usage of the data distribution network. Unlike existing work in the context of video stream processing which provides multiple resolutions by establishing separate channels for each resolution, this paper presents a stream processing system that can efficiently split/combine data streams in order to decrease/increase their resolution without loss in data precision. In addition the system provides mechanisms for load balancing of sensor data streams that allow efficient utilization of the bandwidth of the global sensor network.

The k nearest neighbor (KNN) query, an essential query for information processing in sensor networks, has not received sufficient attention in the research community of sensor networks. In this paper, we examine in-network processing of KNN queries by proposing two alternative algorithms, namely the GeoRouting Tree (GRT) and the KNN Boundary Tree (KBT). The former is based on a distributed spatial index structure and prunes off the irrelevant nodes during query propagation. The latter is based upon ad-hoc geographic routing and first obtains a region within which at least k nearest sensor nodes are enclosed and then decides the k nearest nodes to the query point. We provide an extensive performance evaluation to study the impact of various system factors and protocol parameters. Our results show that GRT yields a good tradeoff between energy consumption and query accuracy in static scenarios. On the other hand, KBT achieves better energy efficiency while being more tolerant to network dynamics.

The early Internet of Things stream processing platforms were mainly designed to collect and display real‐time raw sensor measurements. Data often has to go through several phases of processing to lead to actionable automatic or human decision making. This chapter discusses five main operations performed on streaming data: compression, dimensionality reduction, summarization, learning, and visualization. It distinguishes two main types of stream data processing systems. The first type, also called a data stream management system, is based on relational database principles and introduced the concept of continuous queries. The second type does not enforce a relational view and enables the creation of custom operators. Based on batch and stream processing paradigms, two data processing architectures emerged: the Lambda architecture, which enables both batch and stream processing, and the simpler Kappa architecture, which enables stream processing.