Mario A. Lopez

Indexing the positions of continuously moving objects

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.

STR: a simple and efficient algorithm for R-tree packing

Presents the results from an extensive comparison study of three R-tree packing algorithms: the Hilbert and nearest-X packing algorithms, and an algorithm which is very simple to implement, called the STR (Sort-Tile-Recursive) algorithm. The algorithms are evaluated using both synthetic and actual data from various application domains including VLSI design, GIS (Tiger files), and computational fluid dynamics. Our studies also consider the impact that various degrees of buffering have on query performance. Experimental results indicate that none of the algorithms as best for all types of data. In general, our new algorithm requires up to 50% fewer disk accesses than the best previously proposed algorithm for point and region queries on uniformly distributed or mildly skewed point and region data, and approximately the same for highly skewed point and region data.

High dimensional similarity search with space filling curves

We present a new approach for approximate nearest neighbor queries for sets of high dimensional points under any L/sub t/-metric, t=1,...,/spl infin/. The proposed algorithm is efficient and simple to implement. The algorithm uses multiple shifted copies of the data points and stores them in up to (d+1) B-trees where d is the dimensionality of the data, sorted according to their position along a space filling curve. This is done in a way that allows us to guarantee that a neighbor within an O(d/sup 1+1/t/) factor of the exact nearest, can be returned with at most (d+1)log, n page accesses, where p is the branching factor of the B-trees. In practice, for real data sets, our approximate technique finds the exact nearest neighbor between 87% and 99% of the time and a point no farther than the third nearest neighbor between 98% and 100% of the time. Our solution is dynamic, allowing insertion or deletion of points in O(d log/sub p/ n) page accesses and generalizes easily to find approximate k-nearest neighbors.

A greedy algorithm for bulk loading R-trees

CM-line loading of R-trees is useful to improve node utilization and query performance. WTepresent an algorithm for bulk loading R-trees -r&id diifers horn previous ones in two aspects (a) it partitions input data into subtrees in a top-down fashion (based on the fact that splits close to the root are likely to have a greater impact on performance), (b) at each tree level, it considers all cuts orthogonal to the coordinate axes that result in packed trees and greedily picks those optimizing an arbitrary cost function. EMm.sive esperirnentation with both real and synthetic data indicate that for region data our algorithm requires up to three times fewer disk accesses than other algorithms. It is the method of choice for data with skew in locations, areas, or aspect ratios. Such data is common in practice. Let n = number of input rectangles Let S = maximumnumber of rectangles per subtree Let M = maximumnumber of entries per node Let f (rl, r2) be the “user-supplied” cost function If n < S return {stop condition} For each dimension d For each ordering considered in this dimension d For i from 1 to [n/iVfl – 1 Let B. = MSR of first i S rectangles Let B1 = MSR of the other rectangles Remember i if f(Bo, BI) is better valued Split input set and orderings at best position.

The effect of buffering on the performance of R-trees

Past R tree studies have focused on the number of nodes visited as a metric of query performance. Since database systems usually include a buffering mechanism, we propose that the number of disk accesses is a more realistic measure of performance. We develop a buffer model to analyze the number of disk accesses required for spatial queries using R trees. The model can be used to evaluate the quality of R tree update operations, such as various node splitting and tree restructuring policies, as measured by query performance on the resulting tree. We use our model to study the performance of three well known R tree packing algorithms. We show that ignoring buffer behavior and using number of nodes accessed as a performance metric can lead to incorrect conclusions, not only quantitatively, but also qualitatively. In addition, we consider the problem of how many levels of the R tree should be pinned in the buffer.

GENERALIZED INTERSECTION SEARCHING PROBLEMS

A new class of geometric intersection searching problems is introduced, which generalizes previously-considered intersection searching problems and is rich in applications. In a standard intersection searching problem, a set S of n geometric objects is to be preprocessed so that the objects that are intersected by a query object q can be reported efficiently. In a generalized problem, the objects in S come aggregated in disjoint groups and what is of interest are the groups, not the objects, that are intersected by q. Although this problem can be solved easily by using an algorithm for the standard problem, the query time can be Ω(n) even though the output size is just O(1). In this paper, algorithms with efficient, output-size-sensitive query times are presented for the generalized versions of a number of intersection searching problems, including: interval intersection searching, orthogonal segment intersection searching, orthogonal range searching, point enclosure searching, rectangle intersection searching, and segment intersection searching. In addition, the algorithms are also space-efficient.

Optimal coverage paths in ad-hoc sensor networks

This paper discusses the computation of optimal coverage paths in an ad-hoc network consisting of n sensors. Improved algorithms, with a preprocessing time of O(n log n), to compute a maximum breach/support path P in optimal (|P|) time or the maximum breach/support value in O(1) time are presented. Algorithms for computing a shortest path that has maximum breach/support are also provided. Experimental results for breach paths show that the shortest path length is on the average 30% less and is not much worse that the ideal straight line path. For applications that require redundancy (i.e., detection by multiple sensors), a generalization of Voronoi diagrams allows us to compute maximum breach paths where breach is defined as the distance to the kth nearest sensor in the field. Extensive experimental results are provided.

Approximating a set of points by a step function

Let S be a set of n points in the plane. We derive algorithms for approximating S by a step function of size k

Hausdorff approximation of convex polygons

We develop algorithms for the approximation of convex polygons with n vertices by convex polygons with fewer (k) vertices. The approximating polygons either contain or are contained in the approximated ones. The distance function between convex bodies which we use to measure the quality of the approximation is the Hausdorff metric. We consider two types of problems: min-#, where the goal is to minimize the number of vertices of the output polygon, for a given distance e, and min-e, where the goal is to minimize the error, for a given maximum number of vertices. For min-# problems, our algorithms are guaranteed to be within one vertex of the optimal, and run in O(n log n) and O(n) time, for inner and outer approximations, respectively. For min -e problems, the error achieved is within an arbitrary factor α > 1 from the best possible one, and our inner and outer approximation algorithms run in O(f(α, P) ċ n log n) and O (f (α, P) ċ n) time, respectively. Where the factor f (α, P) has reciprocal logarithmic growth as α decreases to 1, this factor depends on the shape of the approximated polygon P.

Linear time approximation of 3D convex polytopes

We develop algorithms for the approximation of a convex polytope in R3 by polytopes that are either contained in it or containing it, and that have fewer vertices or facets, respectively. The approximating polytopes achieve the best possible general order of precision in the sense of volume-difference. The running time is linear in the number of vertices or facets.