Arbitrary Query Point Research Articles

A robust, fast, and accurate algorithm for point in spherical polygon classification with applications in geoscience and remote sensing

The point in spherical polygon problem addresses the task of classifying an arbitrary query point as inside, outside, or on the boundary of a polygon drawn using great circle segments on the spherical surface. Point in spherical polygon has numerous applications in the geosciences and remote-sensing, where the problem of sorting point position data onto geographic regions on the surface of the earth or sensor field-of-view often arises. By resorting to a direct solution on the spherical surface, distortions arising from projection can be avoided. We examine the problem, with and without preprocessing, where preprocessing is a step applied when a large number of classifications are evaluated against the same spherical polygon. Several improvements are introduced to the existing point in spherical polygon algorithm (which does not include preprocessing), resulting in significantly faster inclusion queries and better handling of edge cases. Furthermore, we introduce a preprocessing algorithm by means of recursive, nonuniform spatial subdivision of longitudinal regions (“lunes”) on the sphere. With an O(nlogn) preprocessing step and O(n) space requirement, the algorithm decreases query time from O(n) to O(logn) for most “realistic” polygons found in geoscience and remote sensing applications. Several empirical tests demonstrate that the algorithm performs to theoretical expectations.

Single-Point And Triple-Point Queries Visibility Constrained Minimum Link Paths In Simple Polygons

Abstract We study the query version of constrained minimum link paths between two points inside a simple polygon $P$ with $n$ vertices such that there is at least one point on the path, visible from a query point. The method is based on partitioning $P$ into a number of faces of equal link distance from a point. This partitioning is essentially a link-based shortest path map. Initially, we solve this problem for two given points $s$, $t,$ and a query point $q$. Then, the proposed solution is extended to a general case for three arbitrary query points: $s$, $t$ and $q$. In the former case, we propose an algorithm with $O(n)$preprocessing time. For the latter case, we develop an algorithm with $O(n^3)$ preprocessing time. The link distance of a $q$-$visible$ path between $s$, $t$ and the path are provided in time $O(\log n)$ and $O(m+\log n)$, respectively, for the above two cases, where $m$ is the number of links.

Query-Points Visibility Constraint Minimum Link Paths in Simple Polygons

We study the query version of constrained minimum link paths between two points inside a simple polygon P with n vertices such that there is at least one point on the path, visible from a query point. The method is based on partitioning P into a number of faces of equal link distance from a point, called a link-based shortest path map (SPM). Initially, we solve this problem for two given points s, t and a query point q. Then, the proposed solution is extended to a general case for three arbitrary query points s, t and q. In the former, we propose an algorithm with O(n) preprocessing time. Extending this approach for the latter case, we develop an algorithm with O(n3) preprocessing time. The link distance of a q-visible path between s, t as well as the path are provided in time O(log n) and O(m + log n), respectively, for the above two cases, where m is the number of links.

Computing the k-Visibility Region of a Point in a Polygon

Two points p and q in a simple polygon P are k-visible when the line segment pq crosses the boundary of P at most k times. Given a query point q, a positive integer k, and a polygon P, we design an algorithm that computes the region of P that is k-visible from q in O(nk) time, where n denotes the number of vertices of P. This region is called the k-visibility region of q. This is the first algorithm parameterized in terms of k, resulting in an asymptotically faster worst-case running time compared to previous algorithms when k is $o(\log {n})$ , and bridging the gap between the O(n)-time algorithm for computing the 0-visibility region of q in P and the $O(n\log n)$ -time algorithm for computing the k-visibility region of q in P for any k. We also design a data structure of size O(n5) that supports visibility queries, returning the k-visible region of P for any arbitrary query point q in $O(\log {n}+m)$ time, where m denotes the number of vertices on the boundary of the output visibility region.

On Combinatorial Depth Measures

Given a set [Formula: see text] of points and a point [Formula: see text] in the plane, we define a function [Formula: see text] that provides a combinatorial characterization of the multiset of values [Formula: see text], where for each [Formula: see text], [Formula: see text] is the open half-plane determined by [Formula: see text] and [Formula: see text]. We introduce two new natural measures of depth, perihedral depth and eutomic depth, and we show how to express these and the well-known simplicial and Tukey depths concisely in terms of [Formula: see text]. The perihedral and eutomic depths of [Formula: see text] with respect to [Formula: see text] correspond respectively to the number of subsets of [Formula: see text] whose convex hull contains [Formula: see text], and the number of combinatorially distinct bisections of [Formula: see text] determined by a line through [Formula: see text]. We present algorithms to compute the depth of an arbitrary query point in [Formula: see text] time and medians (deepest points) with respect to these depth measures in [Formula: see text] and [Formula: see text] time respectively. For comparison, these results match or slightly improve on the corresponding best-known running times for simplicial depth, whose definition involves similar combinatorial complexity.

Evaluating Top-N queries in n-dimensional normed spaces

For the problem of processing top-N queries, the threshold algorithm (TA) is an important method in many scenarios. The model of top-N queries with TA has three characteristics: (1) the ranking function is monotone, (2) the query point is fixed, and (3) TA scans the sorted index lists unidirectionally. In many database applications, however, there are opportunities for evaluating top-N queries with arbitrary query points and generic (not necessarily monotone) ranking functions. In this paper, we propose an approach for evaluating top-N queries in n-dimensional normed spaces. Given a query point Q = (q1,…, qn) in the real vector space ℜn and a generic norm distance d as ranking function, our method employs the norm equivalence theorem in Functional Analysis so that the candidate tuples of top-N query Q with d can be obtained using the Maximum distance d∞. This method projects each qi on its corresponding axis and constructs an interval centered at qi, and then enlarges each interval bidirectionally until the n-dimensional hyperrectangle contains enough candidate tuples so that the top-N tuples are retrieved according to the given norm distance d. Extensive experiments are conducted to measure the performance of our approach for both low-dimensional and high-dimensional data.

Dimensionality reduction for histogram features: A distance-adaptive approach

Histogram representations of visual features, such as high dimensional Bag-of-Features (BOF) and Spatial Pyramid Matching (SPM) representation, have been widely studied and adopted in image classification and retrieval due to their simplicity and performance. Problems involving high dimensional feature vectors usually require much computational cost and huge storage space. Moreover, it may additionally suffer from low accuracy because of the noise in data. In this paper we propose a novel distance-adaptive dimensionality reduction framework, namely generalized Multidimensional Scaling, with linear coding time to create compact and discriminative BOF or SPM representations. Comparing with traditional MDS, our approach exhibits two advantages, on one hand it is adaptive to many measures; on the other hand, it is able to map arbitrary query points into the new space. Exhaustive experimental results show that a very low dimension of BOF or SPM is sufficient for the retrieval task without losing accuracy. Comparatively, the state-of-the-art methods cannot achieve high accuracy on the low dimension. Aside from image retrieval task, we also show that our approach is much more effective than the original histogram representations when applied in image classification task.

Aggregate estimations over location based services

Location based services (LBS) have become very popular in recent years. They range from map services (e.g., Google Maps) that store geographic locations of points of interests, to online social networks (e.g., WeChat, Sina Weibo, FourSquare) that leverage user geographic locations to enable various recommendation functions. The public query interfaces of these services may be abstractly modeled as a k NN interface over a database of two dimensional points on a plane: given an arbitrary query point, the system returns the k points in the database that are nearest to the query point. In this paper we consider the problem of obtaining approximate estimates of SUM and COUNT aggregates by only querying such databases via their restrictive public interfaces. We distinguish between interfaces that return location information of the returned tuples (e.g., Google Maps), and interfaces that do not return location information (e.g., Sina Weibo). For both types of interfaces, we develop aggregate estimation algorithms that are based on novel techniques for precisely computing or approximately estimating the Voronoi cell of tuples. We discuss a comprehensive set of real-world experiments for testing our algorithms, including experiments on Google Maps, WeChat, and Sina Weibo.

On processing reverse k-skyband and ranked reverse skyline queries

In this paper, for the first time, we identify and solve the problem of efficient reverse k-skyband (RkSB) query processing. Given a set P of multi-dimensional points and a query point q, an RkSB query returns all the points in P whose dynamic k-skyband contains q. We formalize RkSB retrieval, and then propose five algorithms for computing the RkSB of an arbitrary query point efficiently. Our methods utilize a conventional data-partitioning index (e.g., R-tree) on the dataset, and employ pre-computation, reuse and pruning techniques to boost the query efficiency. In addition, we extend our solutions to tackle an interesting variant of reverse skyline queries, namely, ranked reverse skyline (RRS) query where, given a data set P, a parameter K, and a preference function f, the goal is to find the K reverse skyline points that have the minimal score according to the user-specified function f. Extensive experiments using both real and synthetic data sets demonstrate the effectiveness of our proposed pruning heuristics and the performance of our proposed algorithms under a variety of experimental settings.

Localized geometric query problems

A new class of geometric query problems are studied in this paper. We are required to preprocess a set of geometric objects P in the plane, so that for any arbitrary query point q, the largest circle that contains q but does not contain any member of P, can be reported efficiently. The geometric sets that we consider are point sets and boundaries of simple polygons.

Fast Approximation of High-Order Voronoi Diagrams and Distance Transforms on the GPU

We present a graphics hardware implementation of the tangent-plane algorithm for computing the kth-order Voronoi diagram of a set of point sites in image space. Correct and efficient implementation of this algorithm using graphics hardware is possible only with the use of an appropriate shader program on the GPU. This is achieved by rendering in k passes the parallel projection of the top k levels of an arrangement of planes tangent to the paraboloid z = x2+y2. Each level of the arrangement corresponds to the so-called kth-nearest point diagram, which is interesting in its own right. Composition of the images of the k top levels results in the kth-order Voronoi diagram. The diagram facilitates efficient computation of the k nearest neighbors of an arbitrary query point. We describe our implementation of the algorithm in OpenGL and Cg, and several optimizations. We also show how to efficiently compute the distance transform of the given sites using the GPU, based on the first-order Voronoi diagram.

Constant Time Queries on Uniformly Distributed Points on a Hemisphere

Abstract A set of uniformly distributed points on a hemisphere is generated using a popular method based on triangle subdivision. In computer graphics applications, each data point (for example, representing a direction from a point on a surface) is typically associated with additional information (for example, a radiance value). Given an arbitrary query point on the hemisphere, we require the nearest data point from the given distribution. An algorithm is presented that finds the data point in constant time, independently of the number of original points in the distribution. A portion of the hemisphere is rendered such that each point in the distribution has an associated set of quadrilaterals rendered with a unique color index for that point. The frame-buffer for the rendered hemisphere portion can be stored in off-screen memory. Any query point can be projected into this off-screen frame buffer, projected to a ‘pixel” location, and the color index stored at this pixel location found. This color index is a lookup into an array of the original data points. This algorithm is presented in detail, and an illustrative implementation in OpenGL is described. The sample code is available at the website given at the end of this paper.

ON GEOMETRIC PATH QUERY PROBLEMS

In this paper, we study several geometric path query problems. Given a scene of disjoint polygonal obstacles with totally n vertices in the plane, we construct efficient data structures that enable fast reporting of an "optimal" obstacle-avoiding path (or its length, cost, directions, etc) between two arbitrary query points s and t that are given in an on-line fashion. We consider geometric paths under several optimality criteria: L m length, number of edges (called links), monotonicity with respect to a certain direction, and some combinations of length and links. Our methods are centered around the notion of gateways, a small number of easily identified points in the plane that control the paths we seek. We give efficient solutions for several special cases based upon new geometric observations. We also present solutions for the general cases based upon the computation of the minimum size visibility polygon for query points.

Shortest Path Queries Among Weighted Obstacles in the Rectilinear Plane

We study the problems of processing single-source and two-point shortest path queries among weighted polygonal obstacles in the rectilinear plane. For the single-source case, we construct a data structure in O(nlog3/2n) time and O(nlog n) space, where n is the number of obstacle vertices; this data structure enables us to report the length of a shortest path between the source and any query point in O(log n) time, and an actual shortest path in O(log n+ k) time, where k is the number of edges on the output path. For the two-point case, we construct a data structure in O(n2 log2n) time and space; this data structure enables us to report the length of a shortest path between two arbitrary query points in O(log2 n) time, and an actual shortest path in O(log2 n + k) time. Our work improves and generalizes the previously best-known results on computing rectilinear shortest paths among weighted polygonal obstacles. We also apply our techniques to processing two-point L1 shortest obstacle-avoiding path queries among arbitrary (i.e., not necessarily rectilinear) polygonal obstacles in the plane. No algorithm for processing two-point shortest path queries among weighted obstacles was previously known.

Rectilinear short path queries among rectangular obstacles

Given a set of n disjoint rectangular obstacles in the plane whose edges are either vertical or horizontal, we consider the problem of processing rectilinear approximate shortest path queries between pairs of arbitrary query points. Our goal is to answer each approximate shortest path query quickly by constructing a data structure that captures path information in the obstacle-scattered plane. We present a data structure for rectilinear approximate shortest path queries that requires O( n log 2 n) time to construct and O( n log n) space. This data structure enables us to report the length of an approximate shortest path between two arbitrary query points in O( log n) time and the actual path in O( log n + L) time, where L is the number of edges of the output path. If the query points are both obstacle vertices then the length and an actual path can be reported in O(1) and O( L) time respectively. The approximation factor for the approximate shortest paths that we compute is 3. The previously best known solution to this problem requires O( n log 3 n) time and O( n log 2 n) space to build a data structure, which supports length and actual path queries respectively in O( log 2 n) and O( log 2 n + L) time (regardless of the types of query points); the approximation factor for paths between arbitrary query points is 7.

ORTHOGONAL SHORTEST ROUTE QUERIES AMONG AXES PARALLEL RECTANGULAR OBSTACLES

Given a set ℬ of n barriers, the shortest route query SRQ problem asks for a preprocessing of ℬ such that a description of the shortest route between two points (origin and destination) can be reported efficiently. In this manuscript we present efficient sequential and parallel algorithms for the SRQ problem where the barriers in ℬ are disjoint planar rectangles whose sides are parallel to the coordinate axes, and subsequent queries ask for the shortest L1 route between two arbitrary points which avoids the barriers in ℬ. The segments forming such route are also restricted to be parallel to the coordinate axes. For this problem we we present sequential and parallel preprocessing algorithms which allow for reporting the shortest distance between two arbitrary query points in O( log n) time with a single processor. The route itself can also be constructed in time proportional to its number of segments. Our method is based on constructing three planar graphs, called carrier graphs, that contain the shortest route information in a succinct form. Each graph can then be searched using graph theoretic techniques. Using the same techniques we also present a parallel algorithm for computing the orthogonal shortest distance between two points among rectangular obstacles which runs in poly-logarithmic time using sub-quadratic number of processors on the CREW PRAM model of computation.

A unified approach to geometric problems using dual cone transformation:

This paper uses a new transformation technique that allows a unified treatment to a number of geometric problems. In particular, we are able to offer an optimal algorithm for range query and point enclosure problems. More specifically, we discuss how our approach yields efficient algorithms to the following three classical problems in computational geometry: (1) Given a collection of d-rectangles in E d , how many of them intersect an arbitrary query rectangle. (2) Give a collection of rectangles which of them contain an arbitrary query point. (3) Given a set of n points in R d and a query d-range q, report the points of S that lie within q. All these results represent significant improvements over the best methods previously known.

A Randomized Algorithm for Closest-Point Queries

An algorithm for closest-point queries is given. The problem is this: given a set S of n points in d-dimensional space, build a data structure so that given an arbitrary query point p, a closest point in S to p can be found quickly. The measure of distance is the Euclidean norm. This is sometimes called the post-office problem. The new data structure will be termed an RPO tree, from Randomized Post Office. The expected time required to build an RPO tree is $O(n^{\lceil {{d / 2}} \rceil (1 + \epsilon )} )$, for any fixed $\epsilon > 0$, and a query can be answered in $O(\log n)$ worst-case time. An RPO tree requires $O(n^{\lceil {{d / 2}} \rceil (1 + \epsilon )} )$ space in the worst case. The constant factors in these bounds depend on d and $\epsilon $. The bounds are average-case due to the randomization employed by the algorithm, and hold for any set of input points. This result approaches the $\Omega (n^{\lceil {{d / 2}} \rceil } )$ worst-case time required for any algorithm that constructs the Voronoi...

Time and space efficient algorithms for shortest paths between convex polygons

Two algorithms are presented for computing shortest paths in the plane avoiding convex polygonal obstacles. For the first algorithm, the obstacles are assumed to consist of f disjoint convex polygons; for the second algorithm, the boundaries of the f polygons may intersect pairwise at most twice. For finding the shortest path between two arbitrary query points, the first algorithm takes O( fn log n) time and O( n) space, the second algorithm preprocesses the polygons in O( n log n+ f 3) time and O( n+ f 2) space. Thereafter, one query takes O( n log n+ f 2) time.

A locally optimal fast obstacle-avoiding path-planning algorithm

Two algorithms to compute the shortest collision-free paths in the Euclidean plane are presented. The ƒ obstacles assumed to be described by disjoint convex polygons having N vertices in total. After preprocessing time O( N+ flog N), a suboptimal shortest path between two arbitrary query points can be found in O( f+ Nlog N) time using Dijkstra's algorithm and in Θ( N) time using the A ∗ algorithm. The space complexity is O( N+ f).