Auto-generation of a centerline graph from a geometrically complex roadmap of real-world traffic systems using a hierarchical quadtree for cellular automata simulations

TL;DR

This paper introduces a hierarchical quadtree-based method to automatically generate centerline graphs from complex real-world traffic roadmaps, facilitating cellular automata traffic simulations and network analysis.

Contribution

The paper presents a novel approach combining quadtree decomposition and space-filling curves to extract centerline graphs from complex roadmaps for traffic modeling.

Findings

Successfully generated centerline graphs from real-world airport maps.

Enabled effective network analysis using Dijkstra's algorithm.

Demonstrated applicability to complex traffic systems.

Abstract

This paper proposes a method of auto-generation of a centerline graph from a geometrically complex roadmap of real-world traffic systems by using a hierarchical quadtree for cellular automata simulations. Our method is summarized as follows. First, we store the binary values of the monochrome image of target roadmap (one and zero represent the road and the other areas, respectively) in the two-dimensional square map. Second, we recursively divide the square map into sub-leafs by a quadtree until the summed-up value of pixels included inside the leaf becomes equal to or less than one. Third, we gradually remove the distal leaves that are adjacent to the leaves whose depths are shallower than the distal leaf. After that, we trace the remaining distal leaves of the tree using Morton's space-filling curve, while selecting the leaves that keep a certain distance among the previously selected leaves as the nodes of the graph. Finally, each selected node searches the neighboring nodes and stores them as the edges of the graph. We demonstrate our method by generating a centerline graph from a complex roadmap of a real-world airport and by carrying out a typical network analysis using Dijkstra's method.

Full text

††journal: Information Sciences

1 INTRODUCTION

Cellular automaton (CA), which was established by Neumann [1], has attracted scientists and researchers for years. Notably, after Wolfram found the Elementary CA Rule 184 [2], the various families of CA have been acknowledged in the field of traffic flow problems. In recent vehicular traffic simulations, cellular automata have taken advantage of fine-grained background cells to represent the complex geometries of real-world systems. As depicted in Fig.1, the system selects representative cells from the background cells as the checkpoints and constructs a graph by connecting them. Because the vehicles move on the centerlines of the routes of the graph during simulations [3, 4, 5, 6, 7], it is necessary to extract a centerline graph from a roadmap for pre-processing in realistic vehicular traffic simulations.

This study aims to conduct a preliminary research as the first step toward the auto-generation of the network graph used in practical traffic CA simulations. Promising approaches for centerline extraction from twisted paths can be found in computed tomography [8, 9], environmental and urban engineering [10, 11, 12, 13, 14, 15], distance-measurement based learning algorithms[16, 17, 18, 19, 20, 21, 22, 23], and topological thinning [24, 25, 26, 27, 28, 29, 30, 31, 32]. Here, focusing our interest on the problems of vehicular traffic simulations restricts the geographic shape of the target graphs, which are summarized as follows: (1) A two-dimensional graph is sufficient. (2) The graph passes around the centerline of the original road map when it is on straight roads. (3) The graph has multiple lanes at intersections in order to represent various movements of vehicles around corners in realistic cases. Figure 2 illustrates the characteristics of (1) to (3) for reference. By considering these restrictions in this study, we can develop new techniques that comprises both straightforwardness and computational efficiency compared to the aforementioned related studies.

In this paper, we propose a method to generate a centerline network graph from geometrically complex roadmaps of real-world systems by dynamically changing the structure of a hierarchical tree, by taking advantage of the characteristics of solid images. Our proposed method can be summarized as follows. First, we store the binary values of the monochrome image of target roadmap (one and zero represent the road and the other areas, respectively) in the two-dimensional square map. Second, we recursively divide the square map into sub-leafs by a quadtree until the summed-up value of pixels included inside the leaf becomes equal to or less than one. Third, we gradually remove the distal leaves that are adjacent to the leaves whose depths are shallower than that of the distal leaf, during the shrinking process. After that, we trace the remaining distal leaves of the tree using Morton’s space-filling curve [33, 34, 35, 36], while selecting the leaves that keep a certain distance from among the previously selected leaves as the nodes of the graph. Finally, each selected node searches the neighboring nodes and stores them as the edges of the graph. In short, we attempt to generate a centerline graph just by releasing the distal leaves.

Our method significantly improves computational efficiency compared to the existing algorithms. For example, a grid search technique associated with the distance functions requires a computational time of $O(N^{\rm 2})$, where $N$ indicates the number of pixels in one direction of the square map. If a graph generation algorithm includes the traveling salesman problem (TSP), it requires a computational time of $O(N!)$ to get the exact solutions, and $O(N^{\rm 2}{\rm 2}^{N})$ to get approximations using a dynamic programming algorithm in typical cases[37], where $N$ indicates the number of nodes. Meanwhile, the topological thinning-based algorithm reported in [32], which is the closest to our approach, requires a computational time of $O(N^{\rm 2})$, where $N$ indicates the number of leaves. The reason for the high computational costs is because the algorithm in [32] carries out the reconstruction of a quadtree in every iterative step of the shrinking process. In contrast, our method requires a one-time recursive tree construction. Substantially, our algorithm requires a computational time of $O(k{\rm log}N)$ to $O(kN)$ for a shrinking process, where $k$ indicates a scalar constant value. In this manner, our method not only has significant straightforwardness but also shows computational efficiency equal to that of the fastest state-of-the-art algorithms such as the one in [22]. Note that, based on these advantages, we determine the value corresponding to the parameter $k$ experimentally, as discussed in Section 2.4.

The remainder of this paper is structured as follows. Section 2, which is divided into four parts, describes our method. In Section 3, we analyze the shortest path search using Dijkstra’s algorithm. Section 4 summarizes our results and concludes this paper.

2 METHOD

Figure 3 shows the target roadmap, which we abstracted from a real-world airport, namely the Tokyo International Airport in Japan. We can divide our method into four processes: the construction process of a recursive tree on the roadmap, the release of distal leaves, the selection of nodes, and the connection of nodes by tracing the distal leaves using a space-filling curve. Figure 4 shows a flowchart of our proposed method.

2.1 Data structure of leaves

We store each element of the monochrome image of the roadmap depicted in Fig. 3 in a corresponding cell of the two-dimensional $N_{\rm r}\times N_{\rm r}$ array. Here, the value of one or zero in each cell represents the road and the other areas, respectively. The parameter $N_{\rm r}$ denotes the number of cells in either of the vertical or horizontal directions in the original roadmap, whichever is larger. After that, we recursively divide the square map into $2\times 2$ sub-leafs by a quadtree, each leaf of which has the following data structure:

Here, the vectors $L_{\rm min}$ and $L_{\rm max}$ indicate the minimum and maximum coordinates of the leaf and correspond to $(0,0)$ and $(N_{\rm r},N_{\rm r})$ at a depth of zero, respectively. The parameter $D$ represents the depth of the leaf. The parameter $R$ indicates the ordering index designated by their parent leaf, which determines the geometric location of the leaf among the bundle of sub-leafs. A space-filling curve is a recursive curve that fills a space or area with a single stroke of a brush [33, 34]; by making the ordering indices of sub-leafs correspond to the space-filling curve, we can trace all the distal leaves using a sequential single curve. Here, the ordering pattern $R$ is individually determined by the type of space-filling curve. There exist several types of space-filling curves[38]. In this paper, we use Morton’s curve (Z-curve) because of its simplicity. The Morton’s curve gives indices between [math] and $4$ to the sub-leafs; therefore, the trajectory of traversing the sub-leafs produces a “Z” shape. Hence, the parameter $R$ is always a number from [math] to $4$.

The binary parameter $F_{\rm end}$ represents whether the leaf is a distal leaf or not. We determine the $F_{\rm end}$ of each leaf in Algorithm 1, which is shown later. Meanwhile, we use the binary parameter $F_{\rm del}$ and parameter $S_{\rm del}$ to judge whether we can release the distal leaf or not in Algorithm 5. In addition, the parameter $F_{\rm chk}$ indicates whether we can select the leaf as a node of the graph or not, and we obtain $F_{\rm chk}$ of each leaf using Algorithm 6.

2.2 Recursive quadtree construction

Algorithm 1 describes the procedure of the recursive quadtree construction. Lines2-9 show the process of initialization of all the parameters of each leaf. In the process after line9, we recursively divide the $N_{\rm r}\times N_{\rm r}$ map into $2\times 2$ sub-leafs by a quadtree. The parameter $B_{\rm p}$ indicates the state of a cell, which becomes one when the leaf is inside the road and zero in other cases. In line10, we define $B_{\rm p}^{\rm s}$ as the summed up value of $B_{\rm p}$ inside the leaf. We keep performing recursive division of the tree until the value of $B_{\rm p}^{\rm s}$ in each leaf becomes equal to or less than one. As a result, each of the deepest distal leaves corresponds to a single cell on the road. Figure 5 shows a hierarchically structured mesh constructed on the roadmap of the airport depicted in Fig. 3. Here, two important observations are made. First, the distal leaves covering the cells on the inner edges of the roads always have the maximum depth of the tree. Second, each cell on the inner edges of the roads are always adjacent to the other leaves that have a shallower depth than the cell. By utilizing these characteristics, we retain only the leaves located around the centerline by releasing leaves through the processes in Algorithms 3 to 5.

Figure 6 shows the process of tracing all the distal leaves by “a single stroke of a brush” using Morton’s curve. Here, for easy access to the distal leaf of the tree, we introduce a conventional technique of a pointer table as shown in Algorithm 2. We can set a sequential number for all the distal leaves by incrementing the number every time Morton’s curve traverses two different distal leaves. We can create one more $N_{\rm r}\times N_{\rm r}$ array and fill the area paved by a distal leaf with the index of the leaf. Similarly, it is possible to store the pointer of each distal leaf in an $N_{\rm r}\times N_{\rm r}$ array, as shown in line8. This pointer table not only makes it easier to access all the distal leaves but also simplifies all the algorithms. Additionally, we store a pointer of the parent leaf in line 2, which we use in the process of releasing the leaves in Algorithm 5.

2.3 Release of distal leaves

Figure 7 illustrates a schematic of releasing the distal leaves. Here, we consider a one-dimensional case using a binary tree for easy explanation. The parameter $D_{\rm max}^{\rm mes}$ indicates the maximum depth of the tree measured by tracing all the distal leaves using Morton’s curve. First, we find out the leaves that are adjacent to the leaves having a shallower depth by one level compared to the deepest leaf. We flag them as the candidates and change their $F_{\rm del}$ from false to true. In this case, we flag the leaf $d$ and leaf $f$ as the candidates because leaf $e$ has a shallower depth. We need to prevent the tree from over-releasing leaves because the tree releases them by units of a bundle of sub-leafs. We count the number of $F_{\rm del}$ whose state is true in every bundle of sub-leafs and store it in the $S_{\rm del}$ of their parent leaf. When the $S_{\rm del}$ of a leaf is zero, the leaf has no candidate sub-leaf to be released. Hereinafter, we refer to such a leaf as “a stable leaf.” Next, leaf B searches the state of neighboring leaves (A and C). Because leaf B is connected with a stable leaf A, we keep the distal leaf $d$ as a candidate sub-leaf to be released. On the other hand, we have to exclude leaf $f$ from the list of candidates regardless of the state of leaf D because leaf $f$ connects with a vacant leaf $g$, which is located outside the roads. In the end, leaf B, a bundle comprising leaf $c$ and leaf $d$, is released.

Algorithm 3 shows the procedure of selecting the candidates to be released. First, we detect one of the distal leaves by the process in lines 2-6. After finding a distal leaf, we examine the depth of the four neighboring leaves existing in the vertical or horizontal direction of the distal leaf as described in lines12-26. If we find that at least one of the four neighboring leaves has a shallower depth than $D_{\rm max}^{\rm mes}$, we change the $F_{\rm del}$ of the leaf from false to true as shown in lines27-29. After that, in Algorithm 4, we count the number of $F_{\rm del}$ whose state is true in every bundle of sub-leafs and store it in the $S_{\rm del}$ of their parent leaf as described in lines 9-14. As aforementioned, when the value of $S_{\rm del}$ of a leaf becomes zero, the leaf has no candidate sub-leaf to be released (the leaf can be considered a “stable leaf”).

Finally, we remove leaves according to the procedure in Algorithm 5. We detect one of the parents of the distal leaves through the process in lines2-7. After finding a parent of a distal leaf, we descend to each of the four child leaves of the leaf as described in line10. We then examine the value of $S_{\rm del}$ of each parent of the leaves neighboring each child leaf as described in lines13-24. When the value of $S_{\rm del}$ becomes zero, a bundle of the leaves including the neighboring leaf of the child leaf remains; we conclude that the child leaf is connected to “a stable leaf”. In this case, we change the $F_{\rm nbr}$ from false to true. On the other hand, we check the value of $F_{\rm del}$ of each child leaf. If at least one of $F_{\rm del}$ of child leaves is true, we change $F_{\rm cnd}$ from false to true in lines27-32. As long as both $F_{\rm nbr}$ and $F_{\rm cnd}$ are true, we release all the child leaves as described in lines33-39.

We set the parameter $F_{\rm stop}$ to be false at the root of the tree. By examining the value of $F_{\rm stop}$ after performing Algorithm 5, we can judge whether the release of leaves occurs at least once or not. We repeat the procedures in Algorithms 3 to 5 to shrink the area around the centerline. It should be noted that it is necessary to update the pointer table ${\rm Table(i,j)}$ and $D_{\rm max}^{\rm mes}$ at every step after executing the processes in Algorithms 3 to 5.

Let us define $N_{\rm rep}$ as the number of times the shrinking process is repeated and $N_{\rm rep}^{\rm max}$ as the number of times it is repeated until $F_{\rm stop}$ changes from false to true. Practically, repeating the shrinking process $N_{\rm rep}^{\rm max}$ times often causes over-release of the leaves. In the example shown in Fig. 8, the parameter $N_{\rm rep}^{\rm max}$ becomes eighteen while it is adequate to set $N_{\rm rep}$ to six for generating a centerline graph. Hence, it is reasonable to regard the parameter $N_{\rm rep}^{\rm max}$ as a limit of iteration; at present, the actual number of $N_{\rm rep}$ needs to be adjusted for individual cases in the range from zero to $N_{\rm rep}^{\rm max}$.

The shrinking process by using Algorithms 2 to 5 requires less computational time compared to the case of reconstructing quadtrees in every step of the $N_{\rm rep}$ iterations. Figure 9 shows a comparison of the computational time consumed for the shrinking process between the repetitive reconstruction of quadtree and the proposed method, on a single core of an Intel Core i7-8650U CPU (1.90GHz). The result shows that our approach reduces the computational time by about 2.95 times compared to the repetitive tree reconstruction-based method.

2.4 Selection and connection of nodes

After shrinking the road areas using Algorithm 5, we trace all the remaining distal leaves of the tree by Morton’s curve to choose the nodes from these distal leaves, which keep a certain distance, from among the previously selected nodes as described in Algorithm 6. To begin with, we detect one of the distal leaves by using the procedure in lines2-6. After finding a distal leaf, we check the distance between the leaf and all the already registered nodes in lines8-14. Here, the parameter $N_{\rm chk}^{\rm crr}$ represents the number of registered nodes. If all the distances between the leaf and each node registered at that time become larger than a certain distance $\eta$, we change the $F_{\rm chk}$ of the leaf from false to true and add the leaf to the list of registered nodes. After that, we increment the parameter $N_{\rm chk}^{\rm crr}$ by one as shown in line18.

Algorithm 7 describes the procedure of connection of nodes, and Figure 10 shows its schematic view. First, we define a cut-off radius $\epsilon$. Each node searches the other nodes located within the range $\epsilon$ as in lines5-6 of Algorithm 7. When the node $j$ finds that another node $i$ satisfies this condition, the node $j$ checks whether the relative vector from node $j$ to node $i$ only traverses the cells on the roads as shown in lines7-18. If it is true, the node $j$ adds the node $i$ to its connectivity list as shown in lines19-21.

The cut-off radius $\epsilon$ is the parameter that controls the degree of connectivity among the nodes; we experimentally determine it within a few times as large as the parameter $\eta$ in typical cases to strengthen the connectivity at intersections while keeping the geometry of the original roadmap. To summarize, we have two deterministic parameters and two experimental parameters: the number of cells in one direction $N_{\rm r}$, the distance among nodes $\eta$, the number of times of repeating the shrinking process $N_{\rm rep}$, and the cut-off radius $\epsilon$.

Figure 11 shows a graph generated from the roadmap of Fig. 1 by using the procedures in Algorithms 1 to 7, and Figure 12 shows an enlarged view of Fig. 11. The white-colored rectangle lines indicate the hierarchically structured leaves at a depth of zero, for reference. We set the pair of $(N_{\rm r},\eta,N_{\rm rep},\epsilon)$ to be $(2048,8,8,28)$ to generate the graph. It was confirmed that the paths were constructed near the centerlines for the straight roads and multiple lanes were connected around each intersection.

3 GRAPH NETWORK ANALYSIS

3.1 A short path search using Dijkstra’s algorithm

As a case study, we carry out a shortest-path finding using Dijkstra’s algorithm for a network generated from the Tokyo International Airport in Japan. In one example, we calculate the shortest paths from the entrance of the high-speed taxiway in runway B to the departure lane of runway C or that of runway D via a checkpoint in Terminal 1. Figure 13 shows the calculated paths from node $a$ to node $b$ or node $c$ via node $d$ by using Dijkstra’s algorithm, and Figure 14 shows an enlarged view of Figure 13. Several reasonable results are observed. First, the calculated paths show a characteristic of Euclidean distance rather than Manhattan distance because of the high-resolution image of the roadmap. We confirmed that the path connecting node $a$ and node $d$ crosses the runway A as diagonally as possible. This is understandable because of the “triangle inequality” relation among the three edges of a rectangle, the diagonal vertices of which are given as node $a$ and node $b$. A similar explanation can be made for the fact that the path connecting node $d$ and node $c$ shows two straight lanes including a single corner.

3.2 Discussions for future work

As mentioned in the Introduction, this paper aims to conduct a preliminary study as the first step toward the auto-generation of the network graph used in practical traffic CA simulations. To discuss the applicability of our method to traffic CA simulations quantitatively, we examine the node connectivity of the generated graph in Fig.14. Figures 15(a) to (e) show the histograms of the node connections for different $\epsilon$ between 12 and 44; the horizontal axis indicates the number of connections per node, and the vertical axis shows their distributions in each case. In Fig.15(c), the nodes on the straight roads contribute to the emergence of a peak at the value of six, which indicates that the nodes on the straight lines connect each other not only between the neighboring nodes but also among three nodes away in the front and back directions. It can be said that this redundant connectivity could enrich the functionality of the applications such as bypass roads or passing phenomena. Furthermore, Fig.15(f) shows the dependence of the positions of the peaks generated by the nodes of the straight roads on the parameter $\epsilon$. Figure 15 clearly shows that the number of connections between nodes on straight roads is proportional to the parameter $\epsilon$.

Meanwhile, the nodes at the intersections contribute to the moderate distribution at the lower part of each case. The dispersion of each distribution directly correlates to that of the connections at each node; thus, the sharp distribution provides a high uniformity for the number of selections of paths at intersections. From Fig.15(a), it can be seen that most of the nodes at the intersections connect with two nodes because of the small $\epsilon$, and therefore the second peak emerges (here, we several nodes disconnect from each other because the parameter $\epsilon$ is too small; as for the setting of the parameter $\epsilon$, we must adjust the parameter $\epsilon$ experimentally as described in Section 2.4). In any case, the histograms in Fig.15 give an objective view of the generated graphs. Further comparisons of these histograms in different related methods must be conducted in a future work.

4 CONCLUSIONS

In this paper, we proposed an effective method for the auto-generation of a centerline graph from geometrically complex roadmaps of real-world traffic systems by using a hierarchically structured tree.

Our method is summarized as follows. First, we store the binary values of a solid image of a roadmap in a two-dimensional square map. Second, we recursively divide the square map into sub-leafs by a quadtree until the summed-up value of pixels included inside the leaf becomes equal to or less than one. Third, we gradually remove the distal leaves that are adjacent to the leaves whose depths are shallower than the distal leaf during the shrinking process. After that, we trace the remaining distal leaves of the tree using Morton’s curve, while selecting the leaves that keep a certain distance from among the previously selected leaves as the nodes of the graph. In the end, each selected node searches the neighboring nodes and stores them as the edges of the graph.

The features of our method are as follows: (1) a straightforward method using only a hierarchical tree without combining any other supportive algorithms such as distance function, (2) the direct generation from a solid image, and (3) multiple lanes at each intersection. Besides, our method significantly improves computational efficiency compared to the existing algorithms; it requires only a one-time recursive tree construction. This is a significant point compared to the previous studies.

Additionally, we demonstrated the shortest-path findings of the generated graph using Dijkstra’s algorithm. It is quite meaningful that we successfully established a methodology to generate a network graph that is suitable for the studies of vehicular traffic CA simulations.

Acknowledgements

This research was supported by MEXT as “Post-K Computer Exploratory Challenges” (Exploratory Challenge 2: Construction of Models for Interaction Among Multiple Socioeconomic Phenomena, Model Development and its Applications for Enabling Robust and Optimized Social Transportation Systems)(Project ID: hp190163), partly supported by JSPS KAKENHI Grant Numbers 25287026, 15K17583 and 18H06459. We would like to thank Editage (www.editage.jp) for English language editing.