Map Creation for Autonomous Robots and Vehicles

1. Introduction

We have introduced a modular design methodology of building autonomous vehicles

in our previous article, Build your own autonomous vehicles with DragonFly technologies (https://www.perceptin.io/blog/build-your-own-autonomous-vehicle-with-dragonfly-technologies). Based on the article, an autonomous vehicle can be easily built by composing PerceptIn's perception module, localization module, planning and control module, and chassis. However, to enable an autonomous vehicle to navigate in some area, such as a campus or a

city, roads and lanes information are further needed.

For a general autonomous vehicle system, a map system provides the information of roads

and lanes. Currently, fully autonomous cars (such as Waymo's and Uber’s autonomous cars)

use high definition 3D maps. Such high precision maps are extremely complex and contain trillion bytes of data to represent not only lanes and roads, but also semantic and locations

of 3D landmarks in the real world [1]. With high definition maps, autonomous vehiclesare

able to localize itself and navigate in the mapped area. However, high definition maps are

also extremely expensive to construct and to maintain, making it extremely hard for ubiquitous deployment.

To address this problem, at PerceptIn we extend existing digital maps, such as OpenStreetMap [2], for autonomous robot and vehicle navigation. This blog describes PerceptIn's mapping technology that enables users to easily construct their own maps.

To achieve this, we have developed a graph-based data structure to represent lanes' topology, and a methodology to construct the map by only using a RTK GNSS receiver [4] and the JOSM toolchain [3]. The proposed map can be easily integrated into the off-the-shell digital map, such as open street map (OSM), to form a two-layered map. With lanes' psychical information provided by the layered map, planning and control module is able to plan a global route for navigation, and to generate a local trajectory and a series of control commands to maneuver the car.

In the rest of the blog, we will discuss three topics of our map. Firstly, the data structure of PerceptIn's map will be introduced. Then, we will briefly describe how to create the map by using a RTK GPS and JOSM. Finally, we will show a demo that simulates navigation behavior on the map.

2. PerceptIn Map Topology

The PerceptIn map uses a set of nodes and edges to represent lanes' structure. Without loss of generality, we use a simplified road model in this blog only for the illustration purpose, which is that a road contains one or multiple directional lane, such that a vehicle can travel on one direction on the lane. In our map products. The following figure shows a simple map that consists of four nodes and four edges. In practice, nodes are physical points centered in the lane. Edges between nodes represents the connectivity between nodes. For example, the edge between node 0 and node 1 represents that node 1 is reachable from node 0.

Fig. 1. Example of our map’s topology

We use the following data structure to describe the topology of the above map. Each row represents a node. The first row contains information of node 0, the second row contains information of node 1, and so on. In a particular row, the first and second column are x and y coordinate (under UTM coordinates) of the node, the third column is the number of nodes connected with this node (i.e. adjacent nodes of this node), and the rest of columns list the ID of adjacent nodes.

Take the first row as an example to explain the data structure.

• This row contains information of node 0.

• X1 and Y1 presents the x and y coordinate of node 0.

• 2 represents the number of adjacent nodes,

• 1 and 3 are IDs of adjacent nodes of node 0.

3. Creating a Map

This section illustrates our method of creating a map. We use a subarea of University of California, Irvine (UCI) campus as an example and create a map of roads around the Anteater Recreation Center, which is illustrated as follows.

Fig. 2. the Anteater Recreation Center. The red line is the lane map that we want to make.

According to maps' data structures discussed in the previous section, to compose a map, coordinates of nodes and connectivity among nodes are need to be determined. In practice, we use a RTK GNSS device and JOSM to obtain the coordinates of nodes, and use JOSM to draw nodes and edges between nodes.

Take the map of lanes around the Anteater Recreation Center as an example. To create the map, firstly, we mount the RTK GNSS module on PerceptIn DragonFly pod [5]. Then, we drive the DragonFly pod along the lanes that we want to make a map for, and use the RTK GNSS device to obtain the trajectory of the car. Secondly, we load the trajectory into JOSM and draw nodes along the trajectory. Finally, we use JOSM to draw the edges between nodes. The following figure shows the obtained map.

Fig. 3. The resulting map in the JOSM

4. Map Demo

The generated map can either be used by DragonFly pod for autonomous navigation or be used by PerceptIn's simulator (PI-SIM) to visualize the car's navigation behavior, especially for planning and control algorithm development. By using the simulator, users can verify if there are problems with the map. The following video shows DragonFly pod's navigation on the map. Features and details of PerceptIn’s simulator will be published on our technical blog soon. Please stay tuned.

5. References

1. Jiao, J., 2018, July. Machine Learning Assisted High-Definition Map Creation. In 2018 IEEE 42nd Annual Computer Software and Applications Conference (COMPSAC)

2. Open Street Map, accessed Dec 1 2018, https://www.openstreetmap.org/

3. JOSM, accessed Dec 1 2018, https://josm.openstreetmap.de/

4. DragonFly RTK GNSS Module, accessed Dec 1 2018, https://www.perceptin.io/products

5. DragonFly Pod, accessed Dec 1 2018, https://www.perceptin.io/products

6. Create a map of UCI campus for autonomous robots and vehicles, accessed Dec 1 2018, https://www.youtube.com/watch?v=Mvmzs9QMt1M&feature=youtu.be