KR20230071671A - Method for processing spatial proximity queries in dynamic spatial networks - Google Patents

Abstract

A method for processing a spatial proximity query in a dynamic spatial network of a location-based service system according to an embodiment of the present invention includes collecting spatial proximity (SP) queries and data points from a plurality of terminals, Grouping query points into query clusters, executing a cluster search algorithm for batch processing on the query clusters including nearest neighbor (NN) queries and range (RN) queries, and the clusters and returning a query result calculated by a search algorithm to the plurality of terminals.

Description

METHOD FOR PROCESSING SPATIAL PROXIMITY QUERIES IN DYNAMIC SPATIAL NETWORKS}

The present invention relates to a location-based service, and more particularly, to a method for processing a spatial proximity query in a dynamic spatial network at high speed.

As location search and service technologies, such as mobile communication networks and GPS, have developed, interest in applications supporting location-based services of moving objects has recently increased. In particular, various services that efficiently search for the nearest vehicle or provide a search service for the nearest parking lot, such as a car calling company or a parking guidance service, are appearing. In this case, a spatial proximity (SP) query must be processed in the dynamic spatial network. A Spatial Proximity (SP) query refers to a set of Nearest Neighbor (hereinafter referred to as NN) queries and Range Neighbor (hereinafter referred to as RN) queries, which are the basic query types of a spatial database. Nearest Neighbor (NN) queries ask the query user to search for the nearest Points Of Interest (POIs), such as taxis and restaurants, while Range (RN) queries retrieve POIs within query distance. request a search In general, Location-Based Services (LBS), such as taxi reservations and ridesharing services, use real-time spatial data to find points of interest (POIs) close to the querying user.

When multiple Spatial Proximity (SP) queries arrive at the Location Based Service (LBS) server at the same time during peak hours, processing the Spatial Proximity (SP) queries sequentially may not provide prompt responses to query users. These difficulties can be addressed by increasing the number of LBS servers or by developing modern algorithms based on "processing one query at a time" to expedite spatial proximity (SP) queries. Spatial proximity (SP) queries have many potential applications in dynamic spatial networks, such as ride-hailing and parking facilities. For example, in 2020, Uber achieved an average of 18.7 million trips per day, demonstrating the importance of a scalable and efficient solution to quickly connect Uber taxis with passengers. Another example is a real-time parking management application that helps drivers find parking spaces close to their destination.

Different types of queries, such as nearest-neighbor queries and range queries, in simple solutions retrieve data points sequentially. However, this involves unnecessary network traversal, which can lead to prohibitively high computational costs when many spatial proximity (SP) queries hit the location-based service (LBS) server during peak hours. Therefore, there is an urgent need for a technique capable of effectively and efficiently processing a spatial proximity (SP) query in a dynamic spatial network.

(1) Korean Patent Publication No. 10-2014-0102373 (2014.08.22) (2) Korea Patent Registration No. 10-1450525 (2014.10.07)

SUMMARY OF THE INVENTION The present invention is to solve the above technical problem, and an object of the present invention is to provide a unified placement algorithm (UBA) capable of effectively and efficiently processing a spatial proximity query in a dynamic spatial network.

A method for processing a spatial proximity query in a dynamic spatial network of a location-based service system according to an embodiment of the present invention includes collecting spatial proximity (SP) queries and data points from a plurality of terminals, Grouping query points into query clusters, executing a cluster search algorithm for batch processing on the query clusters including nearest neighbor (NN) queries and range (RN) queries, and the clusters and returning a query result calculated by a search algorithm to the plurality of terminals.

As an embodiment, the step of executing the cluster search algorithm includes acquiring candidate data points by performing a cluster search at boundary points of the query clusters, and executing a segment search algorithm for the candidate data points. do.

As an embodiment, the cluster search at the boundary point is performed when the query cluster includes only the nearest neighbor (NN) query, when it includes only the range (RN) query, and when the query cluster includes only the nearest neighbor (NN) query. Data point search conditions vary depending on the case in which all of the range (RN) queries are included.

As an embodiment, the segment search algorithm has different distance values when the candidate data point exists inside the query segment and when the candidate data point exists outside the query segment.

According to an embodiment of the present invention, a unified placement algorithm (UBA) capable of effectively and efficiently processing a spatial proximity query in a dynamic spatial network may be implemented.

Figures 1a and 1b respectively show two snapshots of spatial proximity (SP) queries in a dynamic spatial network.
2 is a block diagram showing a location-based service system according to an exemplary embodiment of the present invention.
3 is a diagram for showing terms and notations used in the present invention.
4 is a table summarizing symbols and notations used in the present invention.
5 is a diagram showing an example of a Spatial Proximity (SP) query.
6A and 6B are diagrams illustrating a procedure of converting a query point close to the SP queries of FIG. 5 into a query cluster.
7A and 7B are diagrams showing a method of calculating a distance between a data point (p) and a query segment (/qiqj).
8 is a flowchart briefly showing an integrated batch processing method for a spatial proximity query according to the present invention.
FIG. 9 is a diagram showing a first algorithm corresponding to the flowchart of FIG. 8 .
10 is a flowchart showing step S130 of FIG. 8 in more detail.
FIG. 11 is a diagram showing a second algorithm (cluster_search) performed in FIG. 10 as an example.
FIG. 12 is a diagram showing the segment_search (third algorithm) mentioned in FIG. 11 in detail.
13 is a table comparing the time complexity of the unified placement algorithm (UBA) and sequential algorithms such as INE and RNE in dynamic spatial networks.
14 is a table showing calculation of a spatial proximity query at a boundary point.
15 is a table showing how to calculate a distance between a query point and candidate data points.
16 and 17 show three real spatial networks and experimental parameters.
18 to 21 are graphs showing experimental results for explaining the effect of the present invention.

Hereinafter, some embodiments of the present invention will be described in detail with reference to exemplary drawings. In adding reference numerals to components of each drawing, the same components may have the same numerals as much as possible, even if they are displayed on different drawings. In addition, in describing the present invention, if it is determined that a detailed description of a related known configuration or function may obscure the gist of the present invention, the detailed description may be omitted.

Figures 1a and 1b respectively show two snapshots of spatial proximity (SP) queries in a dynamic spatial network. 1A shows spatial proximity (SP) queries at timestamp t _i , and FIG. 1B shows spatial proximity (SP) queries at timestamp t _j . Here, the spatial proximity (SP) query point set Q and data point set P are expressed as Q={q ₁ ^NN , q ₂ ^RN , q ₃ ^NN } and P={p ₁ , p ₂ , p ₃ }, respectively.

In the present invention, it is assumed that both query points and data points run freely within the spatial network and that spatial segments often change weights. Nearest neighbor queries (q ₁ ^NN , q ₃ ^NN ) find the closest data point to point (q ₁ ^NN ) and point (q ₃ ^NN ), respectively, and area query (q ₂ ^RN ) finds the point (q ₂ ^RN ) to find data points within a query distance (e.g. 4 km). As can be seen in FIG. 1A , at timestamp t _i , data point p ₁ is closest to all nearest neighbor queries q ₁ ^NN , q ₃ ^NN , and data point p ₂ is closest to area query (q NN ). ₂ ^RN ) within 4 km. On the other hand, at the timestamp (t _j ) in FIG. 1B , the data point (p ₃ ) is closest to the nearest neighbor queries (q ₁ ^NN ), and the data point (p ₁ ) is closest to the nearest neighbor queries (q ₃ ^NN ). , and there is no data point located within 4 km of the area query (q ₂ ^RN ). In the case of applying the simple solution, data points satisfying the condition of each spatial proximity (SP) query are sequentially retrieved from the queries Q={q ₁ ^NN , q ₂ ^RN , q ₃ ^NN }. However, this simple solution involves unnecessary network traversal, which can result in excessively high computational cost when many spatial proximity (SP) queries hit the LBS server during peak hours in the network.

2 is a block diagram showing a location-based service system according to an exemplary embodiment of the present invention. Referring to FIG. 2, the location-based service system 100 integrates a location-based service (hereinafter referred to as LBS) server 130 that collects queries transmitted from various terminals without distinguishing between a nearest neighbor query and an area query. It includes a unified placement algorithm (150, UBA) that computes query requests.

The query points 110 corresponding to the terminals requesting the query transmit the current location and query request to the LBS server. The query points 110 receive query responses processed by the integrated placement algorithm 150 of the present invention, and proceed with additional services according to the query responses.

The LBS server 130 collects location information and query requests provided by each of the query points 110 and transmits them to the integrated placement algorithm 150 . And the LBS server 130 receives the query response processed by the integrated placement algorithm 150 and returns it to the query points 110 that requested the service.

The integrated placement algorithm 150 first forms a query cluster by grouping adjacent queries for shared calculation of query points (Step 3). The coalescing placement algorithm 150 then searches candidate data points for each query cluster to avoid unnecessary network traversal (step 4). The coalescing placement algorithm 150 then computes each query using the candidate data points for the query cluster (step 5). And the integrated placement algorithm 150 returns the query result to the LBS server 130 (step 6). Then, the LBS server 130 transmits the query result to each query point (step 7).

All nearest neighbor queries (q ₁ ^NN , q ₃ ^NN ) are similar to spatial proximity (SP) queries. However, since all nearest neighbor queries (q ₁ ^NN , q ₃ ^NN ) assume that each query point (q) in a set of query points (Q) finds only the single closest data point, we do not consider area (RN) queries. . The present invention assumes a highly dynamic situation in which query points and data points are freely executed within a dynamic spatial network. The unified placement algorithm 150 of the present invention can effectively process spatial proximity (SP) queries in a dynamic spatial network. For simplicity, the present invention considers NN queries rather than k-NN queries that, for a positive integer k, retrieve the k data points closest to the querying user. However, it will be appreciated that the union placement algorithm 150 can be easily extended to handle k-NN queries.

The performance of the integrated placement algorithm 150 of the present invention is highly dependent on the distribution of query points. Thus, the unified placement algorithm 150 can provide better performance than sequential algorithms when the query points represent a skewed distribution. Conversely, the coalesced placement algorithm 150 may exhibit similar performance to the sequential algorithm when the query points exhibit a uniform distribution. Clustering and sharing computation of spatial proximity (SP) queries is provided in the present invention to avoid unnecessary distance computation. The correctness of the unified placement algorithm 150 can be proven using a lemma. In addition, a theoretical analysis will be provided to establish the advantages of the unified placement algorithm 150 over sequential algorithms when query points exhibit a skewed distribution. Empirical studies were conducted under various conditions to prove the superiority and scalability of the unified batch algorithm 150 compared to the sequential algorithm.

3 is a diagram for showing terms and notations used in the present invention. Referring to FIG. 3 , each vertex may be marked as an intersection vertex, an intermediate vertex, and a terminal vertex. First, if the degree of a vertex is greater than or equal to 3, the vertex is an intersection vertex. And if the degree of the vertex is 2, the vertex is an intermediate vertex. And in the case of a vertex whose degree is 1, it is a terminal vertex. For example, vertices v ₂ and v ₃ are intersection vertex, vertices v ₅ and v ₆ are intermediate vertex, and vertices v ₁ and v ₄ are terminal vertex. (terminal vertex).

In addition, the NN query used in the present invention is given a query point (q ^NN ) and a data point set P, the NN query searches for a data point (p ^NN ) closest to the query point (q ^NN ), Let 'dist(q ^NN , p ^NN )≤dist(q ^NN , p)' hold for ∀p ^NN ∈Π(q ^NN ) and ∀p∈P−Π(q ^NN ). RN query, given a positive integer r, a query point (q ^RN ), and a set of data points (P), the RN query is such that 'dist(q ^{RN, pRN} )≤r' is ∀p ^RN ∈Π Retrieve a data point within q ^RN at a query distance r such that it holds for (q ^RN ). A dynamic spatial network can be described as a dynamic weight graph G=<V, E, W>. Here, V, E, and W denote a vertex set, an edge set, and an edge distance matrix, respectively. An edge is non-negative and has a frequently changing weight (e.g., travel time).

And the vertex sequence (/v _l v _l+1 …v _m ) represents a segment connecting two vertices v _l and v _m such that v _l and v _m are intersecting vertices or terminal vertices, and the other vertices of the segment, i.e. v _l+1 ,... ,v _m-1 is the middle vertex. The length of a vertex sequence is the total weight of the edges in the vertex sequence. A portion of a vertex sequence is called a segment. By definition, vertex sequences are also segments. For example, FIG. 3 has four vertex sequences /v ₁ v ₂ , /v ₂ v ₃ , /v ₃ v ₄ , /v ₂ v ₅ v ₆ v ₃ . The query segments of FIG. 3 include /v ₂ v ₅ v ₆ , /v ₅ v ₆ and /v ₃ v ₆ v ₅ .

4 is a table summarizing symbols and notations used in the present invention. Referring to Figure 4, query point can sometimes be used interchangeably to refer to an SP query. Referring to FIG. 3 again, a difference between a distance and a segment length between a query point q ₁ and a query point q ₂ in a spatial network is shown. Here, the shortest path between the query point (q ₁ ) and the query point (q ₂ ) is q ₁ →v ₂ →v ₃ →q ₂ , and the distance dist(q ₁ , q ₂ ) is 8. The segment (shown as a thick line) connecting query points (q ₁ ) and query points (q ₂ ) is /q ₁ v ₅ v ₆ q ₂ , with length len (/q ₁ v ₅ v ₆ q ₂ ) equal to 10 am.

5 is a diagram showing an example of a Spatial Proximity (SP) query. Referring to FIG. 5 , five SP queries (q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , q ₅ ^NN ) are illustrated. Here, the NN query (q ₁ ^NN , q ₃ ^NN , q ₅ ^NN ) finds the closest data point to itself, and the RN query (q ₂ ^RN , q ₄ ^RN ) finds the data point within the query distance r (=4). find

6A and 6B are diagrams illustrating a procedure of converting a query point close to the SP queries of FIG. 5 into a query cluster.

Referring to FIG. 6A , in a first step, query points of a vertex sequence are connected to query segments. As a result, three query segments /q ₁ ^NN q ₂ ^RN , q ₃ ^NN , and /q ₄ ^RN q ₅ ^NN are generated. where /q ₁ ^NN q ₂ ^RN and /q ₄ ^RN q ₅ ^NN are respectively two separate sets of query points, i.e. q ₁ ^NN and q ₂ ^RN , q ₄ ^RN and q ₅ ^NN respectively the vertex sequence /v ₁ v ₂ and /v ₁ v ₅ to connect.

Referring to Figure 6b, in the second step, adjacent query segments are grouped into query clusters using joint vertices. An intersection vertex is referred to as a joint vertex when it is adjacent to two or more query segments. As shown, the query segments /q ₁ ^NN q ₂ ^RN and /q ₄ ^RN q ₅ ^NN are adjacent at the intersection vertex (v ₁ ), and the intersection vertex (v ₁ ) is adjacent to the query segment /q ₁ ^NN q ₂ ^RN and / It is the joint vertex of q ₄ ^RN q ₅ ^NN . Similarly, the query segments /q ₁ ^NN q ₂ ^RN and q ₃ ^NN are adjacent to the intersection vertex (v ₂ ), and the vertex (v ₂ ) is the joint vertex of the query segments /q ₁ ^NN q ₂ ^RN and q ₃ ^NN . do. Finally, the query segments q ₃ ^NN and /q ₄ ^RN q ₅ ^NN are adjacent to the intersection vertex (v ₅ ), and the vertex (v ₅ ) is the joint vertex of query segments q ₃ ^NN and /q ₄ ^RN q ₅ ^NN . do.

Thus, three query segments (/q ₁ ^NN q ₂ ^RN , q ₃ ^NN , /q ₄ ^RN q ₅ ^NN ) form the query cluster /Q _C ={/q ₁ ^NN q ₂ ^RN , q ₃ ^NN , /q ₄ ^RN q ₅ ^NN }. That is, five query points q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , and q ₅ ^NN are clustered into a query cluster '/Q _C '. /Q _C denotes a set of query segments. Consequently, the set of query points Q={q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , q ₅ ^NN } is the set of query clusters /Q={/q ₁ ^NN q ₂ ^RN , q ₃ ^NN , /q ₄ ^RN q ₅ ^NN }.

Next, define the border point of the query cluster (/Q _C ). All points where the query cluster (/Q _C ) and the non-query cluster (G-/Q _C ) meet are referred to as border points of the query cluster /Q _C . In this embodiment, the query cluster (/Q _C ) has three boundary points, v ₁ , v ₂ , and v ₅ , where the query cluster (/Q _C ) and the non-query cluster (G-/Q _C ) meet. . The sequential solution has to evaluate the five SP queries (q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , q ₅ ^NN ) shown in FIG. 5 . If _the two-step clustering method _is used, the unified placement algorithm ⁽ ₁₅₀ ^, _{UBA )} uses boundary points ₍ ^{v 1 ,} v ₂ , and v ₅ ) can evaluate three SP queries.

7A and 7B are diagrams illustrating a method of calculating a distance between a data point (p) and a query segment (/q _i q _j ). 7a is a distance calculation when the data point (p) is not included in the query segment (/q _i q _j ), and FIG. 7b is a case where the data point (p) is included in the query segment (/q _i q _j ). It shows the distance calculation of (p∈/q _i q _j ).

Referring to Figure 7a, when the data point p is outside the query segment (/q _i q _j ), the distance from the query point q to the data point p is the shortest path between q and p Since 'q→q _i → p' or 'q→ q _j → p', dist(q, p) = min{len(/qq _i ) + dist(q _{i, p} ), len(qq _j ) + dist(q _j , p)}.

Referring to Figure 7b, when the data point (p) is inside the query segment (/q _i q _j ), the distance from the query point (q) to the data point (p), the shortest path between q and p Since it is one of the three cases 'q→p', 'q→ q _j →p' or 'q→ q _j →p', dist(q, p) = min{len(/qp), len(/ qq _i )+ dist(/q _i , p), len(qq _j ) + dist(q _j , p)}.

8 is a flowchart briefly showing an integrated batch processing method for a spatial proximity query according to the present invention. Referring to FIG. 8 , the coherent placement algorithm may perform batch processing by grouping nearest neighbor (NN) queries and area (RN) queries into individual clusters.

In step S110, the LBS server 130 receives a location and a query request from query points (110, see FIG. 2) requesting a query. That is, the LBS server 130 collects spatial proximity (SP) queries and data points. Spatial proximity (SP) queries and data points collected by the LBS server 130 are transmitted as query request information to the integrated placement algorithm 150 of the present invention.

In step S120, the integrated placement algorithm 150 groups nearby query points into query clusters. For example, as in the description of FIGS. 6A and 6B , three query segments (/q ₁ ^NN q ₂ ^RN , q ₃ ^NN , /q ₄ ^RN q ₅ ^NN ) are each grouped, and then a query cluster / Q _C = {/q ₁ ^NN q ₂ ^RN , q ₃ ^NN , /q ₄ ^RN q ₅ ^NN }.

In step S130, the integrated placement algorithm 150 executes a cluster search function. For example, coalescing placement algorithm 150 may execute a cluster search algorithm for query clusters. That is, the coalesced placement algorithm 150 then searches for candidate data points for each query cluster to avoid unnecessary network traversal. And the coalescing placement algorithm 150 can compute each query using the candidate data points for the query cluster.

In step S140, the integrated placement algorithm 150 returns the query calculation result to the LBS server 130.

FIG. 9 is a diagram showing a first algorithm corresponding to the flowchart of FIG. 8 . Referring to FIG. 9 , the first algorithm (Algorithm 1) may be expressed as a unified placement algorithm (UBA).

According to the Unified Batch Algorithm (UBA), it is possible to perform unified batch processing of SP queries in spatial networks. Here, the result set Π(Q) is initially set to the empty set (line 1). Then, as described in Figures 6A and 6B, nearby query points are first grouped into query clusters (lines 2 and 3). Subsequently, a cluster search (cluster_search) is performed for each query cluster /Q _C to perform batch processing of SP queries, and the query result is stored in Π(/Q _C ) (line 6). Then, the query cluster result Π(/Q _C ) is added to Π(Q). Here, Π(/Q _C )={<q,Π(q)>|q∈/Q _C } and Π(Q)={<q,Π(q)>|q∈Q} line 7). When 'cluster_search (second algorithm) is performed on each query cluster, the query result Π(Q) is returned, and the integrated placement algorithm is terminated (line 8).

10 is a flowchart showing step S130 of FIG. 8 in more detail. Referring to FIG. 10 , a cluster search algorithm for a query cluster is executed. The unified batch algorithm 150 performs batch execution for each query cluster to avoid unnecessary network traversal of the query cluster later.

In step S131, the integrated placement algorithm 150 executes the cluster search algorithm at the boundary point (b) of the query cluster.

In step S133, the integrated location algorithm 150 executes a segment search (Segment_search) algorithm using the candidate data point obtained from the cluster search result at the boundary point (b).

FIG. 11 is a diagram showing a second algorithm (cluster_search) performed in FIG. 10 as an example. Referring to FIG. 11 , a second algorithm (cluster_search) describes a cluster search algorithm used to respond to an SP query in a query cluster (/Q _C ).

The second algorithm (cluster_search) is executed in two steps. In the first step, the SP query is computed at the boundary points of the query cluster (/Q _C ) rather than at the query points of the query cluster (/Q _C ) (lines 3-6). SP queries are either NN queries or RN queries. Therefore, it is necessary to determine the type of spatial proximity (SP) query computed at boundary point (b). If the query cluster (/Q _C ) contains only NN queries, the NN queries are computed at the boundary point (b). That is, SPQ(b, /Q _C )=Π(b ^NN ). Similarly, if the query cluster (/Q _C ) contains only RN queries, the SPQ(b, /Q _C ) function computes the RN queries at the boundary point (b). That is, SPQ(b, /Q _C )=Π(b ^RN ). Finally, if the query cluster (/Q _C ) contains both NN and RN queries, the SPQ(b, /Q _C ) function is an SP that finds all data points that satisfy the NN or RN condition at the boundary point (b). Calculate the query. That is, SPQ(b, /Q _C )=Π(b ^NN )∪Π(b ^RN ).

In the second step, performed in the second algorithm (cluster_search), each query segment (/q _i q j ) of the query cluster (/Q _{C )} is evaluated using the candidate data points obtained from the boundary points of the query cluster (/Q _C ). A sharing calculation is performed on (lines 7-10). Here, each SP query in the query segment (/q _i q _j ) selects a qualifying data point from the candidate data points of Π(b _i )∪Π(b _j )∪P(bi _{b j} ). Here, the query segment (/q _i q _j ) is regarded as belonging to the segment (/b _i b _j ) of the query cluster (/Q _C ). When segment_search (third algorithm) is performed on each query segment in the query cluster (/Q _C ), the cluster_search algorithm (second algorithm) is terminated by returning the query result Π (/Q _C ) (line 11).

FIG. 12 is a diagram showing the segment_search (third algorithm) mentioned in FIG. 11 in detail. Referring to FIG. 12, by segment_search (third algorithm), query segment (/Q _C ) using candidate data points of Π(b _i )∪Π(b _j )∪P(/b _i b _j ) The procedure of the segment search algorithm used to answer the SP query is described.

First, the batch query result for the query segment (/q _i q _j ), i.e. Π(q _i q _j ), is initially set to an empty set (line 1). Then, as shown in FIG. 7A, the distance between the query point q of the query segment (/q _i q _j ) and the candidate data point p, that is, dist(q, p) is calculated (lines 5 to 9). ). Here, when the candidate data point (p) is outside the segment (/b _i b _j ), the distance from the query point (q) to the data point (p) is dist(q, p)=min{len(/qb _i )+dist(b _i , p), len(/qb _j )+dist(b _j , p)}. When the candidate data point (p) is inside the segment (/b _i b _j ), that is, when p∈b _i b _j , the distance from the query point (q) to the data point (p) is dist(q , p) = min{len(/qp), len(/qb _i )+dist(b _i , p), len(/qb _j )+ dist(b _j , p)}.

If the query point q is a NN query, and the candidate data point p is closer to q than the current NN point p ^NN , then the candidate data point p is added to Π(q), and the NN point pNN ) is removed from Π(q). That is, Π(q)←Π(q)∪{p}-{pNN} (lines 11 to 12). Similarly, if query point q is an RN query and dist(q, p) is not greater than the query distance 'q.r' then data point p is added to Π(q). That is, Π(q)←Π(q)∪{p}, where the query distance qr means the query distance of the query point q (lines 13 to 14). In this way, the Segment_search algorithm (third algorithm) ends by returning the batch result Π(/q _i q _{j )} for the query segment (/q _i q j ) (line 16).

Lemma 1 below proves the correctness of the Unified Placement Algorithm (UBA). That is, each query point (q) in the query cluster (/Qc) can retrieve a normalized data point from the candidate data points for the query cluster (/Qc).

* Lemma 1: Each query point (q) in the query cluster (/Qc) can retrieve a normalized data point from the candidate data points for the query cluster (/Qc).

Proof of <lemma 1>

By showing the contradiction that arises from the assumption that there exists a finite data point (p) for query point (q) in query cluster (/Qc) where data point (p) is not a candidate data point for query cluster (/Qc). We can prove lemma 1. Clearly, the set of candidate data points for the query cluster (/Qc) Σ(/Qc) is the set P(/Qc) of data points inside the query cluster (/Qc) and each border point of the query cluster (/Qc). ) is the union of SPQ(b, /Qc): Σ(/Qc)=P(/Qc)∪(SPQ(b _l , /Qc)∪SPQ(b _l+1 , /Qc)∪ …∪SPQ(b _m , /Qc), where B(/QC)={b _l , b _l+1 ,…, b _m } Clearly, this data point (p) is outside the query cluster (/Qc). This is because, according to the definition of Σ(/Qc) as shown in Fig. 7b, the definite data point p inside the query cluster (/Qc) becomes the candidate data point of the query cluster (/Qc) Normalized data When the point (p) is outside the query cluster (/Qc) as shown in FIG. 7A, the following two equations should be considered.

For Equation 1, the specified data point p satisfies the range query q ^RN . However, it is not a candidate data point for the query cluster (/Qc). For Equation 2, the prescribed data points p satisfy the NN query q ^NN . However, it is not a candidate data point for the query cluster (/Qc). The shortest path from the area query (q ^RN ) to the data point (p) must pass through the boundary of the query cluster (/Qc). For convenience, it is assumed that the shortest path from the area query (q ^RN ) to the data point (p) is q ^RN → b _l → p. Here, b _l is the boundary point of the query cluster (/Qc). The distance from the area query (q ^RN ) to the data point (p) is less than or equal to the query distance r. That is, dist(q ^RN , p)≤r. Therefore, the distance from the boundary point b _l to the data point p is also less than or equal to 'r'. That is, dist(b _l , p) ≤ r. This leads to a contradiction to the assumption that a qualifying data point (p) for a range query (q ^RN ) is not a candidate data point for a query cluster (/Qc).

Next, consider the second case where the prescribed data point p for the nearest neighbor query q ^NN is not a candidate data point for the query cluster /Qc. For convenience, we assume that the shortest path from a nearest neighbor query (q ^NN ) to a data point (p) is q ^NN → b _l → p and that the data point (p _l ) is the nearest neighbor (NN) of b _l , not p. do. This means that the data point (p _l ) is closer to b _l than to p. That is, dist(b _l , p _l ) < dist(b _l , p). The shortest path from a nearest neighbor query (q ^NN ) to a data point (p _l ) is q _NN → b _l → p(q ^NN → b _l → p _l ). Therefore, the data point (p _l ) must be the nearest neighbor (NN) of the nearest neighbor query (q ^NN ), not p. This contradicts the assumption that the data point p is the nearest neighbor (NN) of the nearest neighbor query (q ^NN ). Therefore, each query point (q) in the query cluster (/Qc) can retrieve a normalized data point from the candidate data points in the query cluster (/Qc).

13 is a table comparing the time complexity of the unified placement algorithm (UBA) and sequential algorithms such as INE and RNE in dynamic spatial networks. Referring to Figure 13, the unified batch algorithm (UBA) of the present invention is independent of one-query-at-a-time algorithms and can be easily incorporated into such algorithms. For simplicity, INE and RNE are considered as evaluating a single spatial proximity (SP) query in a dynamic spatial network, with time complexity 'O'(|E|+|V|ㆍlog|V|).

The Unified Batch Algorithm (UBA) is Mㆍ|/Q| Calculate as many as the number of SP queries. Here, |/Q| is the number of query clusters (/Q), and M represents the maximum number of boundary points of the query cluster (/Qc). That is, M = max{|B(/Qc)|, /Qc∈/Q}. Conversely, since each query point must be processed individually, the sequential algorithm |Q| Calculate as many as the number of SP queries. Therefore, the time complexities of the unified batch algorithm (UBA) and the sequential algorithm are 'O'(|/Q|ㆍ(|E|+|V|ㆍlog|V|)) and 'O'(|Q|ㆍ(| E|+|V|ㆍlog|V|)). The results of the time complexity analysis indicate that the unified batch algorithm (UBA) outperforms the sequential algorithm. In particular, the unified placement algorithm (UBA) is superior when |/Q|≪|Q|, that is, when the query points exhibit a highly skewed distribution. In addition, the above comparison results show that the unified batch algorithm (UBA) exhibits performance similar to that of the sequential algorithm when |/Q|∼|Q| and query points show a uniform distribution.

14 is a table showing calculation of a spatial proximity query at a boundary point. Referring to FIGS. 6A, 6B, and 14, five spatial proximity queries (q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , q ₅ ^NN ) using the unified placement algorithm (UBA) are The query clusters /Qc with boundary points (v ₁ , v ₂ , v ₅ ) are grouped into = {/q ₁ ^NN q ₂ ^RN , /q ₃ ^NN , /q ₄ ^RN q ₅ ^NN }.

The set of query points Q = {q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , q ₅ ^NN } is the set of query clusters /Q = {/q ₁ ^NN q ₂ ^RN , /q ₃ ^NN , /q ₄ ^RN q ₅ ^NN }. The Unified Placement Algorithm (UBA) uses not five query points (q ₁ ^NN , q ₂ ^RN , q ₃ ^NN , q ₄ ^RN , q ₅ ^NN ) but three spatial proximity at the boundary of a set of query clusters (/Q). (SP) Only queries are computed. The query cluster (/Qc) contains both NN queries (q ₁ ^NN , q ₃ ^NN , q ₅ ^NN ) and RN queries (q ₂ ^RN , q ₄ ^RN ). Therefore, the result of the spatial accessibility (SP) query at boundary points (v ₁ , v ₂ , v ₅ ) is Π(v ₁ )=Π(v ₁ ^NN )∪Π(v ₁ ^RN ), Π(v ₂ )=Π (v ₂ ^NN )∪Π(v ₂ ^RN ), Π(v ₅ )=Π(v ₅ ^NN )∪Π(v ₅ ^RN ). 14 shows spatial accessibility (SP) query results at three boundary points (v ₁ , v ₂ , v ₅ ).

Segment_search (third algorithm) is called by each query segment in the query cluster (/Q _C ). For convenience, it is assumed that three query segments (/q ₁ ^NN q ₂ ^RN , /q ₃ ^NN , /q ₄ ^RN q ₅ ^NN ) are sequentially processed. First, the Segment_search function is Π(v ₁ ^NN )∪Π(v ₁ ^RN )∪Π(v ₂ ^NN )∪Π(v ₂ ^RN )∪P(/v ₁ v ₂ ) = {p ₂ , p ₄ } Calculates the SP query into candidate data points. This function calculates the distance between a query point pair (q ₁ ^NN and q ₂ ^RN ) and candidate data points (p ₂ , p ₄ ) within a query segment (/q ₁ ^NN q ₂ ^RN ).

15 is a table showing how to calculate a distance between a query point and candidate data points. Referring to FIG. 15 , the distance between each query point pair (q) of the query segment (/q _i q _j ) and the candidate data point (p) is summarized. Here, the SP query (q ₁ ^NN ) finds the closest data point to the query point (q ₁ ^NN ) from the candidate data points (p ₂ and p ₄ ). As a result, since the candidate data point (p ₄ ) is closer to the query point (q ₁ ^NN ) than the candidate data point (p ₂ ), the data point (p ₄ ) is the selected nearest neighbor (NN) of the query point (q ₁ ^NN ). ) becomes Similarly, the SP query (q ₂ ^RN ) finds data points within query distance r=4. Therefore, since dist(q ₂ ^RN , p ₂ )=4 and dist(q ₂ ^{RN, p} ₄ )=11, the result of q ₂ ^RN contains the data point p ₂ . The query result for the query segment (/q ₁ ^NN q ₂ ^RN ) is Π(/q ₁ ^NN q ₂ ^R )=Π(q ₁ ^NN )∪Π(q ₂ ^RN )={<q ₁ ^NN ,{p ₄ }>, <q ₂ ^RN , {p ₂ }>}.

Next, the segment_search function calculates Π(v ₂ ^NN )∪Π(v ₂ ^RN )∪Π(v ₅ ^NN )∪Π(v ₅ ^RN )∪P(/v ₂ v ₅ ) = {p ₁ , p ₂ } Compute the SP query with the candidate data points of First, the distance between each pair of query points (q ₃ ^NN ) and candidate data points (p ₁ , p ₂ ) is calculated. Then, the SP query (q ₃ ^NN ) finds the closest data point to the query point (q ₃ ^NN ) from the candidate data points (p ₁ , p ₂ ). Consequently, since p ₁ is closer to the query point (q ₃ ^NN ) than p ₂ , p ₁ becomes the selected nearest neighbor (NN) of the query point (q ₃ ^NN ). The query result for q ₃ ^NN becomes Π(q ₃ ^NN )={<q ₃ ^NN , {p ₁ }>}.

_Finally ^{, the segment_search} _{function has} ^the _{following equation : _} Compute the SP query (/q ₄ ^RN q ₅ ^NN ) using the candidate data points. First, the distance between each pair of query points in the query segment (/q ₄ ^RN q ₅ ^NN ) and the candidate data points (p ₁ , p ₄ ) is calculated. The SP query (q ₄ ^RN ) finds data points within the query distance r=4. Since dist(q ₄ ^RN , p ₁ )=9 and dist(q ₄ ^RN , p ₄ )=8, there are no data points in the result set of the SP query (q ₄ ^RN ). The SP query (q ₅ ^NN ) identifies the closest data point to q ₅ ^NN from data points (p ₁ , p ₄ ). Consequently, since the data point (p ₁ ) is closer to the query point (q ₅ ^NN ) than the data point (p ₄ ), the data point (p ₁ ) is the selected nearest neighbor (NN) of the SP query (q ₅ ^NN ). becomes The query result for the query segment (/q ₄ ^RN q ₅ ^NN ) is Π(/q ₄ ^RN q ₅ ^NN )=Π(q ₄ ^RN )∪Π(q ₅ ^NN )={<q ₄ ^RN , Φ>, <q ₅ ^NN , {p ₁ }>}. Obviously, the results of the SP queries in the query point set (Q) appear as the union of the results of the query segments of the query cluster (/Qc) (Π(Q)= Π(/q ₁ ^NN q ₂ ^RN )∪Π(q ₃ ^NN )∪Π(/q ₄ ^RN q ₅ ^NN )= {<q ₁ ^NN ,{p ₄ }>, <q ₂ ^RN , {p ₂ }>, <q ₃ ^NN , {p ₁ }>, <q ₄ ^RN , Φ>, <q ₅ ^NN , {p ₁ }>}).

<Performance evaluation>

16 and 17 show three real spatial networks and experimental parameters. Referring to Figures 16 and 17, these real space networks are of different sizes and are part of the US road network. For convenience of description, the range of the spatial network is normalized to unit square [0, 1] ² , and the query distance r is set to 10 ^-2 . Query points follow a central distribution, and data points follow a central or uniform distribution. Here, centroid-based points were created to mimic the heavily skewed POI distribution in the real world. First, the centroids (c ₁ , c ₂ , …,c _|C| ) were randomly selected according to the range of the spatial network, and |C| represents the number of centroids. The points around each centroid follow a normal distribution with the mean representing the centroid and the standard deviation set to σ=10 ^-2 . A total of 1 to 10 centroids were selected as query points and 5 centroids were selected as data points. The number of NN queries was equal to the number of RN queries for SP queries. In each experiment, a single parameter was changed within a range and the other parameters were kept at their default values.

Next, the integrated batch algorithm 150 of the present invention was compared with a sequential algorithm called SEQ that sequentially calculates SP queries in terms of query processing time and the number of evaluated SP queries. Here we assume that queries and data points move freely within a dynamic spatial network. When queries and data points run freely within dynamic spatial networks, it is impractical to utilize precomputation techniques presented in the literature because precomputed distances can often become invalid. UBA and SEQ use common subroutines for similar tasks, such as evaluating SP queries at a single query point. Therefore, both algorithms were implemented in C++ using the Microsoft Visual Studio 2019 development environment. Experiments were run on a desktop computer running the Windows 10 operating system with 32GB RAM and a 3.1GHz processor (i9-9900). As in many recent studies, the index structures for UBA and SEQ remain in main memory to provide rapid response, which is important in online map services. The experiment was repeated 10 times and the average processing time was measured to determine the SP query of Q.

As mentioned earlier, the proposed UBA is orthogonal to one query processing algorithm at a time and can be easily incorporated into such algorithms. In the present invention, we used INE and RNE to evaluate NN and RN queries for dynamic spatial networks, respectively, since INE and RNE are based on network expansion similar to the 'Dijkstra algorithm' suitable for dynamic spatial networks.

18 to 21 are graphs showing experimental results. 18 shows the results of comparing query processing times of UBA and SEQ to evaluate SP queries in the CAL roadmap. The three top row and three bottom row charts in FIGS. 18-20 show the experimental results when the data points followed a uniform distribution and a central distribution, respectively. Each chart shows the query processing time and the number of SP queries evaluated by changing one parameter at a time. 18 to 21, the values in parentheses indicate the number of SP queries evaluated by the proposed UBA. The number of SP queries evaluated by SEQ is omitted because it is exactly equal to |Q|.

Referring to FIG. 18A, among the SP queries of the query point set (Q), FIG. 18a shows |Q| Between 1K and 10K of the query points, i.e. 1K≤|Q|≤10K. As shown, our UBA clearly outperformed SEQ as the number of SP queries in Q increased. In terms of query processing time, UBA was up to 2.9 times faster than SEQ for |Q|=7K. However, UBA was up to 2.59 times slower than SEQ for |Q|=1K. Unlike SEQ, the UBA of the present invention is not sensitive to |Q|. This increases the efficiency of batch processing in UBA by the number of query points (|Q|). When |Q|=1K, 3K, 5K, 7K, and 10K, UBA computed fewer SP queries than SEQ by 75%, 89%, 88%, 91%, and 92%, respectively.

Referring to FIG. 18B, |P| The number of data points varied between 1K and 10K. That is, 1K≤|P|≤10K. Thus, UBA clearly outperformed SEQ in all cases. The query processing time of UBA was up to 8.9 times lower than that of SEQ when |P|=1K. Data point |P| As the value decreases, the search space for processing NN queries increases. Regardless of the change in data point |P|, UBA and SEQ counted 789 and 10,000 SP queries, respectively.

Referring to FIG. 18C , query processing time when the number of centroids (|C|) of query points varies between 1 and 10 is shown. That is, 1≤|C|≤10. Our UBA was up to 2.3 times faster than SEQ in all cases. As the number of centroids (|C|) increases, the difference in query processing time between UBA and SEQ decreases because the density of query points decreases and the number of query clusters (|Q|) increases. Specifically, when |C|=1, 3, 5, 7, and 10, UBA computed 789, 1196, 2438, 3928, and 4015 SP queries, respectively, while SEQ computed 10K SP queries for all these cases.

18D-18F show the query processing times of UBA and SEQ when the data points follow a central distribution. The query processing time of UBA of the present invention was at most 18.95 times lower than that of SEQ in all cases. Unlike the case of FIG. 18a, when the data points follow a severely skewed distribution, the query processing time of UBA and SEQ does not increase with |Q| as shown in FIG. This means that the distribution is more sensitive. When |Q|=1K, 3K, 5K, 7K, and 10K, UBA's query processing time was 21.7 seconds, 162.8 seconds, 21.9 seconds, 126.8 seconds, and 468.7 seconds, respectively. As can be seen in Figures 18d to 18f, UBA was faster than SEQ in all cases. The difference in query processing time between UBA and SEQ for a central distribution of data points was up to several orders of magnitude greater than for a uniform distribution of data points.

19a to 19f show results of comparing query processing times obtained when using UBA and SEQ to evaluate SP queries in the FLA roadmap. 19a shows query processing time as a function of |Q|. It can be seen that our UBA is up to 2.2 times faster than SEQ for |Q|≥3K. However, for |Q|=1K, SEQ was 2.7 times faster than UBA. This is because UBA's batch processing is for large numbers, not small numbers, of SP queries.

19B shows the query processing time as a function of |P|. UBA and SEQ computed 1601 and 10,000 SP queries for these two cases, respectively, but UBA was 5.5 and 2.2 times faster than SEQ for |P|=1K and 10K, respectively. This is because when |P|=1K, the search space for the NN query was larger than when |P|=10K.

19C shows the query processing time as |C|, which was shorter by a maximum of 2.1 times than that of SEQ in all cases in the case of UBA. Apparently, the number of query clusters increased to |C|, which negatively affected the performance of the proposed UBA.

As can be seen in Figures 19D-19F, UBA was up to 11 times faster than SEQ in all cases. Both UBA and SEQ query processing times fluctuated. In other words, a heavily skewed distribution of data points greatly affected the NN query processing time. Specifically, as shown in Figure 19d, despite the difference in the number of SP queries in the query point set (Q), the query processing time of UBA for |Q|=1K was 8.9 times longer than that for |Q|=3K.

20a to 20f show results obtained by comparing query processing times obtained using UBA and SEQ with a COL roadmap. As can be seen in FIG. 20a, UBA of the present invention was up to 3.1 times faster than SEQ when 5K≤|Q|≤10K. Here, as |Q| increased, UBA was superior to SEQ.

As shown in Fig. 20b, since UBA and SEQ computed 409 and 10,000 SP queries, respectively, UBA was up to 16.3 times faster than SEQ regardless of |P| value. Clearly, this accounted for the difference in the number of SP queries (i.e. 9591). The UBA of the present invention can use batch processing of clustered SP queries. Thus, unnecessary distance calculations can be avoided.

As can be seen in Fig. 20c, UBA clearly outperformed SEQ in all cases of the number of centroids (|C|). As the number of centroids (|C|) increased, the density of query points decreased, which was inefficient for batch processing of UBA.

As can be seen in Figures 20D-20F, UBA was up to 26.6 times faster than SEQ in all cases. As shown in Fig. 20d, the query processing time of UBA and SEQ fluctuated greatly because the skewed distribution of data points greatly affected the search space of the NN query.

21A and 21B show results of comparing query processing time and CAL roadmap using UBA _SEG and UBA _CLS . By implementing and evaluating two versions of UBA, namely UBA _SEG and UBA _CLS , a two-step clustering method was found to be consistent with UBA's batch processing and |Q| The effect on scalability in terms was investigated. UBA _SEG converts nearby query points into query segments, and UBA _CLS converts nearby query points into query clusters. UBA _SEG and UBA _CLS are shown in FIGS. 6A and 6B , respectively. Here, the two values in parentheses indicate the number of SP queries evaluated by UBA _SEG and UBA _CLS , respectively. As shown, the number of SP queries evaluated by UBA _SEG was greater than that of UBA _CLS .

Referring to FIG. 21A, when data points show a uniform distribution, UBA _SEG is up to 6.1 times faster than UBA _CLS for 1K≤|Q|≤10K. However, the number of query points|Q| When it increases, UBA _CLS is faster than UBA _SEG , which means that UBA _CLS scales better than UBA _SEG with |Q|. In particular, UBA _CLS was 1.5 times faster than UBA _SEG for |Q|=100K.

Referring to FIG. 21B , when the data points show a central distribution, UBA _CLS was up to 2.2 times faster than UBA _SEG in all cases. Therefore, it can be seen that UBA _CLS is |Q| times larger than UBA _SEG . This means that the distribution of data points has a significant impact on query processing time. In particular, when the data points are uniform and show a central distribution, the query processing time of UBA _CLS was 1.5 seconds and 497.7 seconds for |Q|=100K, respectively.

In the present invention, a unified placement algorithm (UBA) is proposed to efficiently process SP queries composed of NN and RN queries in dynamic spatial networks. A goal of the UBA of the present invention is to avoid unnecessary distance calculations during batch processing. Thus, UBA can perform two-step clustering and batching of SP queries to reduce the number of SP queries computed for a query cluster. Experimental results show that the UBA of the present invention outperforms existing algorithms based on processing one query at a time and scales well with the number of queries. We found that our UBA was up to 26.6 times faster than the existing comparison algorithm.

The UBA of the present invention has several advantages. First, the UBA of the present invention clusters SP queries and performs batch processing to prevent unnecessary network searches. Second, the UBA of the present invention can be easily incorporated into one query processing algorithm at a time for spatial networks. However, the UBA of the present invention also has a disadvantage in that performance is very sensitive according to the distribution of query points. Thus, UBA shows similar performance to sequential algorithms, especially when the query points show a uniform distribution. The UBA of the present invention outperforms the sequential algorithm when the query points represent a highly skewed distribution.

The integrated batch solution of the present invention is expected to be applicable to a very large spatial network for distributed batch processing of sophisticated spatial queries such as spatial join queries and spatial keyword queries.

The foregoing are specific examples for carrying out the present invention. In addition to the above-described embodiments, the present invention will also include embodiments that can be simply or easily changed in design. In addition, the present invention will also include techniques that can be easily modified and practiced using the embodiments. Therefore, the scope of the present invention should not be limited to the above-described embodiments and should not be defined, and should be defined by those equivalent to the claims of this invention as well as the claims to be described later.

Claims (4)

A method for processing a spatial proximity query in a dynamic spatial network of a location-based service system comprising:
Collecting spatial proximity (SP) queries and data points from a plurality of terminals;
grouping query points of the spatial proximity query into query clusters;
executing a cluster search algorithm for batch processing of the query clusters comprising a nearest neighbor (NN) query and a range (RN) query; and
and returning a query result calculated by the cluster search algorithm to the plurality of terminals. According to claim 1,
The step of executing the cluster search algorithm is:
acquiring candidate data points by performing a cluster search on boundary points of the query cluster; and
A method of processing a spatial proximity query comprising executing a segment search algorithm for the candidate data points. According to claim 2,
Cluster search at the boundary point,
When the query cluster includes only the nearest neighbor (NN) query, when it includes only the range (RN) query, and when it includes both the nearest neighbor (NN) query and the range (RN) query How to handle spatial proximity queries in which the search conditions for data points vary according to According to claim 2,
The segment search algorithm processes a spatial proximity query having different distance values when the candidate data point exists inside the query segment and when the candidate data point exists outside the query segment.

Images