A local map construction method and device for path planning

Abstract

The present invention discloses a local map construction method and device for path planning. The method includes: based on the reference line of the local map to be planned in the Frenet coordinate system, traversing the preset map according to the perception information and the map information to obtain the road boundary information and obstacle information of the local map to be planned; converting the road boundary information and the obstacle information in the Cartesian system into a grid map, and constructing the occupation grid map of the local map to be planned; based on the occupation grid map, constructing the prefix grid map and the Euclidean distance field grid map of the local map to be planned; performing path planning according to the occupation grid map, the prefix grid map and the Euclidean distance field grid map of the local map to be planned, and obtaining the planned path of the local map to be planned.

Description

Technical Field

[0001] The present invention relates to the field of autonomous driving planning technology, and more particularly, to a method and device for constructing a local map for path planning. Background Art

[0002] In autonomous driving path planning, driving planning is inconvenient in some structured scenarios, such as U-turns and escapes, as well as in driving or parking planning in unstructured scenarios. Planning based on the reference line system built on the Frenet system has certain limitations. At this time, it is necessary to consider planning issues under the Cartesian system. Traditional planning will perform some geometric modeling of obstacles and roads within a certain configuration space, and perform planning and collision detection based on this geometric relationship, such as OBCA and other algorithms, but there is a technical problem of excessive computing power consumption. Summary of the Invention

[0003] In view of the deficiencies of the prior art, the present invention provides a method and device for constructing a local map for path planning.

[0004] According to one aspect of the present invention, a method for constructing a local map for path planning is provided, comprising:

[0005] Based on the reference line of the local map to be planned in the Frenet coordinate system, the preset map is traversed according to the perception information and map information to obtain the road boundary information and obstacle information of the local map to be planned;

[0006] Convert the road boundary information and obstacle information in the Cartesian system into a grid map, and construct an occupancy grid map of the local map to be planned;

[0007] Based on the occupancy grid map, a prefix grid map and a Euclidean distance field grid map of the local map to be planned are constructed;

[0008] Path planning is performed according to the occupancy grid map, the prefix grid map, and the Euclidean distance field grid map of the local map to be planned, and a planned path of the local map to be planned is obtained.

[0009] Optionally, based on the reference line of the local map to be planned in the Frenet coordinate system, traversing the preset map according to the perception information and the map information to obtain the road boundary information includes:

[0010] Based on the reference line of the frenet coordinate system, customize the vertical starting point start_s and the vertical end point end_s;

[0011] Traverse all reference points between the starting point and the end point in the preset map, and read the first leftmost boundary point left_xy and the first rightmost boundary point right_xy of each reference point;

[0012] Read the second leftmost boundary point left_curb_xy and the second rightmost boundary point right_curb_xy of the longitudinal position corresponding to the left and right visual curb information of each reference point;

[0013] Update the first leftmost boundary point left_xy and the second leftmost boundary point left_curb_xy, whichever is closer to the lane center, to the new leftmost boundary point left_xy;

[0014] Update the first rightmost boundary point right_xy and the second rightmost boundary point right_curb_xy, which is closer to the lane center, to the new rightmost boundary point right_xy, and store the new leftmost boundary point left_xy and the new rightmost boundary point right_xy after each reference point is updated into the road boundary container bound_vec to obtain the road boundary information.

[0015] Optionally, based on the reference line of the local map to be planned in the Frenet coordinate system, traversing the preset map according to the perception information and the map information to obtain obstacle information includes:

[0016] Traverse all reference points between the longitudinal starting point start_s and the longitudinal end point end_s;

[0017] Determine the left boundary position left_lim_l and the right boundary position right_lim_l of the widest point in this longitudinal interval according to the left boundary left_l and the right boundary right_l of each reference point;

[0018] Traverse all static obstacles provided by the perception function, filter out obstacles that are completely outside the longitudinal start point start_s and the longitudinal end point end_s, and obstacles that are completely outside the left boundary position left_lim_l and the right boundary position right_lim_l, and store the remaining obstacles that meet the requirements after filtering into the obstacle container obs_vec to obtain obstacle information.

[0019] Optionally, converting the road boundary information and obstacle information in the Cartesian system into a grid map to construct an occupancy grid map of the local map to be planned includes:

[0020] Traverse the road boundary information and obtain the four extreme positions to determine the local map boundary in the Cartesian system;

[0021] Define the grid resolution step, x-axis grid number, y-axis grid number, and Cartesian origin coordinates of the grid map based on the local map boundary;

[0022] Initialize the two-dimensional array bin_map, setting each position to 0;

[0023] Traverse all elements in the obstacle information bound_vec, use the line segment rasterization tool to read all the first grid point sequences passing through the line connecting the two points before and after the traversal, and set the positions in the two-dimensional array bin_map represented by the grid point coordinates in all the first grid point sequences to 1;

[0024] Call the edge fill tool to set all the parts from the grid boundary in the two-dimensional array bin_map to the obstacle information bound_vec stored in the fusion of the map lane and the perception roadside boundary to 1;

[0025] Define the first grid map obs_map with the same number of rows and columns as the two-dimensional array bin_map to represent obstacles, and set each position to 0;

[0026] Traverse each obstacle in the first grid map obs_vec, then traverse the contour points of each obstacle in the second layer, use the line segment rasterization tool to read all the second grid point sequences passing through the line connecting the two contour points before and after the traversal, and set the positions in the first grid map obs_map represented by the grid point coordinates of all the second grid point sequences to 1;

[0027] Call the edge filling tool to set the portion between the grid boundary in the first grid map obs_map and the obstacle outline boundary stored in the obstacle information obs_vec to 2;

[0028] Traverse the first grid map obs_map and set the obstacle boundary and its interior to 1, and also set the outermost circle of obstacles to 1;

[0029] Traverse the first grid map obs_map, find the position where the grid map obs_map is 1, and update the two-dimensional array bin_map to 1, and build the occupied grid map of the local map to be planned.

[0030] Optionally, the line segment rasterization tool is implemented as follows:

[0031] Input the first starting point start and the first end point end in the Cartesian system, and output the grid point container vx_vec that stores all the grid points that need to be passed from the first starting point start to the first end point end in the grid map;

[0032] Get the vector ray={end[0] - start[0], end[1] - start[1]} formed by the first starting point start and the first end point end of Cartesian. Calculate the line segment according to the vector ray x and yThe moving direction on the axis dir={ray[0]>0?1:-1, ray[1]>0?1:-1}, where the moving directions include: {1, 1}, {1, -1}, {-1, 1} and {-1, -1};

[0033] According to the second starting point start_vx and the second end point end_vx of the grid map obtained by the coordinate converter and the moving direction, the grid point is moved in the x-axis and y-axis directions by one grid resolution step and converted into Cartesian coordinates n_vx={(start_vx[0]+ (dir[0]>0)) * step + base[0], (end_vx[1]+ (di[1]>0)) * step + base[1]};

[0034] According to the Cartesian coordinate point set, initialize t_max={abs((n_vx[0] - start_vx[0]) / ray[0]), abs((n_vx[1] - start_vx[1]) / ray[1])} and t_step={abs(step / ray[0]* dir[0]), abs(step / ray[1]* dir[1])}, where t_max is used to record the time interval to reach the next grid, and t_step is the time increment of each step;

[0035] Add the second starting point start_vx of the grid map to the grid point container vx_vec, define the grid point cur_vx to be initialized as the second starting point start_vx, and if cur_vx has not moved to the second end point end_vx, enter a loop to determine the size of the x-axis and y-axis data in t_max. If the x-axis direction is smaller, t_max[0] += t_step[0] and curr_vx[0]+= di[0] to achieve movement in the x-axis direction, otherwise it will achieve movement in the y-axis direction. After the movement is completed, add the moved grid point cur_vx to the grid point container vx_vec.

[0036] Optionally, the edge filling tool is implemented as follows:

[0037] Traverse the edge of the initial grid map, check whether the value of the edge position is equal to from, and change all connected original values ​​from to the target value to through the breadth-first search tool, where

[0038] Traverse the edges of the initial grid map, check whether the value of the edge position is equal to the original value from, and change all connected original values ​​from to the target value to through the breadth-first search tool, including:

[0039] Traverse each row of the initial grid map, check multiple first values ​​at the first and last column positions, and if multiple first values ​​are the original value from, call the breadth-first search tool starting from the first and last column positions to fill the original value from with the target value to;

[0040] Traverse each column of the initial grid map, check the multiple second values ​​at the first and last rows, and if the multiple second values ​​are from, call the breadth-first search tool starting from the first and last rows to fill the original value from with the target value to.

[0041] Optionally, based on the occupancy grid map, a prefix grid map of the local map to be planned is constructed, including:

[0042] Define a second grid map with the same number of rows and columns as the two-dimensional array, where each position of the second grid map is set to 0;

[0043] The value of each grid point in the second grid map is calculated based on the occupied grid map to obtain the prefix grid map. The calculation formula for the value of each grid point in the second grid map is:

[0044] presum_map[i][j]= bin_map[i - 1][j - 1]+ bin_map[i - 1][j] + bin_map[i][j - 1] -bin_map[i- 1][j - 1], where bin_map is the occupied grid map.

[0045] Optionally, based on the occupancy grid map, a Euclidean distance field grid map of the local map to be planned is constructed, including:

[0046] Define a third grid map with the same number of rows and columns as the two-dimensional array, where each position in the third grid map is set to 0; and initialize a double-ended queue dq and the distance dis from a position to its nearest obstacle to 0;

[0047] Update the position of the occupied position corresponding to 1 in the occupied grid map to -10 in the third grid map, update the position of the unoccupied position corresponding to the occupied grid map to the distance dis in the third grid map, and add the grid point of the unoccupied position to the double-ended queue dq;

[0048] When the double-ended queue dq is not empty, a loop is entered, the first point in the double-ended queue dq is popped out to check its adjacent points. If the adjacent point is in a non-occupied position, it is added to the double-ended queue dq, and the value of its position in the third grid map is set to the current distance dis. After each layer of distance dis value is processed, the grid resolution is increased until all grid points in the third grid map are assigned values, and the Euclidean distance field grid map of the local map to be planned is constructed.

[0049] Optionally, path planning is performed based on the occupancy grid map, the prefix grid map, and the Euclidean distance field grid map of the local map to be planned to obtain a planned path for the local map to be planned, including:

[0050] Evaluate the points in the initial planning path preset and constructed in the local map to be planned according to the occupancy grid map, and update the initial planning path according to the evaluation result to obtain a first updated planning path;

[0051] Evaluate the rectangles in the first updated planned path according to the prefix grid map, and update the first updated planned path according to the evaluation result to obtain a second updated planned path;

[0052] The distances from points in the second updated planned path to obstacles are evaluated according to the prefix grid map, and the second updated planned path is updated according to the evaluation result to obtain a planned path of the local map to be planned.

[0053] According to another aspect of the present invention, there is provided a local map construction device for path planning, comprising:

[0054] A traversal module is used to traverse the preset map based on the reference line of the local map to be planned in the Frenet coordinate system according to the perception information and map information to obtain the road boundary information and obstacle information of the local map to be planned;

[0055] The first construction module is used to convert the road boundary information and obstacle information in the Cartesian system into a grid map, and construct an occupancy grid map of the local map to be planned;

[0056] The second construction module is used to construct a prefix grid map and a Euclidean distance field grid map of the local map to be planned based on the occupancy grid map;

[0057] The planning module is used to perform path planning based on the occupancy grid map, prefix grid map and Euclidean distance field grid map of the local map to be planned, and obtain the planned path of the local map to be planned.

[0058] According to another aspect of the present invention, a computer-readable storage medium is provided, wherein the storage medium stores a computer program, and the computer program is used to execute the method according to any one of the above aspects of the present invention.

[0059] According to another aspect of the present invention, an electronic device is provided, comprising: a processor; a memory for storing instructions executable by the processor; and the processor for reading the executable instructions from the memory and executing the instructions to implement the method described in any one of the above aspects of the present invention.

[0060] Therefore, the present invention proposes a local map construction method for path planning. Based on the reference line of the local map to be planned in the Frenet coordinate system, the preset map is traversed according to the perception information and map information to obtain the road boundary information and obstacle information of the local map to be planned; the road boundary information and obstacle information in the Cartesian system are converted into a grid map to construct an occupancy grid map of the local map to be planned; based on the occupancy grid map, a prefix grid map and a Euclidean distance field grid map of the local map to be planned are constructed; and path planning is performed based on the occupancy grid map, prefix grid map, and Euclidean distance field grid map of the local map to be planned to obtain the planned path of the local map to be planned. Planning and collision detection are performed within the local map constructed by the present invention. Autonomous driving does not have a strong need to compete with dynamic obstacles at the path planning level, and the frame rate of all mapping can be low to reduce computing power consumption. BRIEF DESCRIPTION OF THE DRAWINGS

[0061] A more complete understanding of exemplary embodiments of the present invention may be obtained by referring to the following drawings:

[0062] Figure 1 is a flowchart of a method for constructing a local map for path planning provided by an exemplary embodiment of the present invention;

[0063] Figure 2 is a schematic diagram of an occupancy grid in a U-turn scenario provided by an exemplary embodiment of the present invention;

[0064] Figure 3 is a schematic diagram of an occupation grid map of a local map to be planned provided by an exemplary embodiment of the present invention;

[0065] Figure 4 This is a schematic diagram of a prefix grid map of a local map to be planned provided by an exemplary embodiment of the present invention;

[0066] Figure 5 Schematic diagram of a Euclidean distance field grid map of a local map to be planned provided by an exemplary embodiment of the present invention;

[0067] Figure 6 is a schematic structural diagram of a local map building device for path planning provided by an exemplary embodiment of the present invention;

[0068] Figure 7 This is a structure of an electronic device provided by an exemplary embodiment of the present invention. DETAILED DESCRIPTION

[0069] Below, the exemplary embodiments according to the present invention will be described in detail with reference to the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all the embodiments of the present invention, and it should be understood that the present invention is not limited to the exemplary embodiments described herein.

[0070] It should be noted that the relative arrangement of components and steps, the numerical expressions and numerical values ​​set forth in these embodiments do not limit the scope of the present invention unless specifically stated otherwise.

[0071] Those skilled in the art will understand that the terms "first" and "second" in the embodiments of the present invention are only used to distinguish different steps, devices or modules, and neither represent any specific technical meaning nor indicate the necessary logical order between them.

[0072] It should also be understood that, in the embodiments of the present invention, “a plurality of” may refer to two or more than two, and “at least one” may refer to one, two or more than two.

[0073] It should also be understood that any component, data or structure mentioned in the embodiments of the present invention can generally be understood as one or more, unless explicitly limited or otherwise indicated in the context.

[0074] In addition, the term "and / or" in this invention merely describes an association relationship between related objects, indicating that three possible relationships exist. For example, A and / or B can represent: A exists alone, A and B exist simultaneously, and B exists alone. Furthermore, the character " / " in this invention generally indicates that the related objects are in an "or" relationship.

[0075] It should also be understood that the description of the various embodiments of the present invention focuses on the differences between the various embodiments, and the same or similar aspects thereof can be referenced with each other. For the sake of brevity, they will not be described one by one.

[0076] At the same time, it should be understood that for the convenience of description, the sizes of the various parts shown in the drawings are not drawn according to the actual proportional relationship.

[0077] The following description of at least one exemplary embodiment is merely illustrative in nature and is in no way intended to limit the invention, its application, or uses.

[0078] Technologies, methods, and equipment known to ordinary technicians in the relevant art may not be discussed in detail, but where appropriate, the technologies, methods, and equipment should be considered part of the specification.

[0079] It should be noted that like reference numerals and letters refer to like items in the following figures, and therefore, once an item is defined in one figure, it need not be further discussed in subsequent figures.

[0080] Embodiments of the present invention can be applied to electronic devices such as terminal devices, computer systems, and servers, and can operate in conjunction with numerous other general-purpose or specialized computing system environments or configurations. Examples of well-known terminal devices, computing systems, environments, and / or configurations suitable for use with terminal devices, computer systems, servers, and other electronic devices include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, handheld or laptop devices, microprocessor-based systems, set-top boxes, programmable consumer electronics, network personal computers, minicomputer systems, mainframe computer systems, and distributed cloud computing technology environments including any of the above.

[0081] Electronic devices such as terminal devices, computer systems, and servers can be described in the general context of computer system-executable instructions (such as program modules) executed by a computer system. Generally, program modules can include routines, programs, object programs, components, logic, data structures, etc., which perform specific tasks or implement specific abstract data types. Computer systems / servers can be implemented in a distributed cloud computing environment, where tasks are performed by remote processing devices linked via a communication network. In a distributed cloud computing environment, program modules can be located on local or remote computing system storage media, including storage devices.

[0082] Exemplary Methods

[0083] Figure 1 FIG is a flow chart of a method for constructing a local map for path planning provided by an exemplary embodiment of the present invention. This embodiment can be applied to electronic devices, such as Figure 1 As shown, the local map construction method 100 for path planning includes the following steps:

[0084] Step 101: Based on the reference line of the local map to be planned in the Frenet coordinate system, a preset map is traversed according to the perception information and map information to obtain road boundary information and obstacle information of the local map to be planned;

[0085] Step 102: Convert the road boundary information and obstacle information in the Cartesian system into a grid map, and construct an occupied grid map of the local map to be planned;

[0086] Step 103: constructing a prefix grid map and a Euclidean distance field grid map of the local map to be planned based on the occupancy grid map;

[0087] Step 104 : performing path planning based on the occupancy grid map, the prefix grid map, and the Euclidean distance field grid map of the local map to be planned, and obtaining a planned path of the local map to be planned.

[0088] Specifically, to address the technical issues in the background art, the present invention proposes a method for constructing a local map for path planning. Planning and collision detection are performed within this local map. Autonomous driving does not require strong negotiation with dynamic obstacles at the path planning level, and the frame rate of all map construction can be low to reduce computing power consumption. The specific technical content includes the following:

[0089] Step S1: element acquisition and processing;

[0090] Step S11: element preparation: obstacle information and visual roadside information provided by perception; road boundary information provided by the map;

[0091] Step S11: feature extractor;

[0092] The reference line based on the frenet coordinate system (composed of a series of reference points, which store information such as s, left_l, right_l, left_xy, and right_xy), and the custom vertical start and end points s_start and s_end:

[0093] Traverse all reference points between start_s and end_s, read the left_xy and right_xy of the reference points, read the left_curb_xy and right_curb_xy of the corresponding longitudinal positions of the left and right visual curb information according to the reference point s, compare left_xy and left_curb_xy and take the one closer to the lane center as the updated left_xy, compare right_xy and right_curb_xy and take the one closer to the lane center as the updated right_xy, and store the updated left_xy and right_xy in the road boundary information container bound_vec;

[0094] Traverse all reference points between start_s and end_s, and determine the left and right boundaries of the widest part of this longitudinal interval based on the reference points left_l and right_l. Traverse all static obstacles provided by the sensor, filter out obstacles completely outside start_s and end_s, and filter out obstacles completely outside left_lim_l and right_lim_l, and store the obstacles that meet the requirements in the obstacle information container obs_vec;

[0095] S2: local map construction;

[0096] S21: Information initialization:

[0097] Traverse all elements in bound_vec and find the four extreme positions x_min, x_max, y_im, and y_max to determine the local map boundaries under the Cartesian system

[0098] Custom grid resolution step, x-axis grid number x_size: (x_max - x_min) / step + 1, y-axis grid number y_size: (y_max - y_min) / step + 1,

[0099] Define the Cartesian origin coordinates of the grid map base={x_min, y_min}

[0100] S22: Related tool design

[0101] S221: Coordinate Converter: Converts Cartesian coordinates to grid coordinates (index in the xy direction of the grid)

[0102] S222: Line segment rasterization tool;

[0103] Input the start and end points in the Cartesian system, and output the container vx_vec that stores all the grid points that need to be passed from the start point to the end point in the grid map.

[0104] Get the vector ray={end[0] -start[0], end[1]- start[1]} formed by the Cartesian start and end points. According to the vector ray, calculate the moving direction of the line segment on the x and y axes dir={ray[0]>0 ? 1 : -1, ray[1]>0 ? 1 : -1}, which are four possibilities {1, 1}, {1, -1}, {-1, 1}, {-1, -1}.

[0105] Get the grid start and end points start_vx and end_vx through the coordinate converter, calculate the grid point after moving one step in the x and y directions according to the dir direction, and convert it into Cartesian coordinates n_vx={(start_vx[0] + (dir[0]>0)) * step + base[0], (end_vx[1] + (di[1]>0)) * step + base[1]}

[0106] Initialize t_max={abs((n_vx[0] - start_vx[0]) / ray[0]),abs((n_vx[1] - start_vx[1]) / ray[1])}

[0107] Initialize t_step={abs(step / ray[0]*dir[0]), abs(step / ray[1]*dir[1])};

[0108] Where t_max is used to record the time interval to reach the next grid, the time interval for the ray to advance on each axis, based on the grid size step and the direction of the ray ray; t_step is the time increment of each step, also based on the direction of the ray and the step size.

[0109] First, add start_vx to vx_vec. Define the grid point cur_vx and initialize it to start_vx. If cur_vx has not moved to end_vx, enter a loop to determine which of the x and y axis data in t_max is smaller. If the x direction is smaller, t_max[0] += t_step[0] and curr_vx[0] += di[0] to achieve the x-direction movement. The same applies to the y direction. After the movement is completed, add the moved grid point cur_vx to vx_vec.

[0110] S223: Edge filling tool;

[0111] Pass in the grid map, the updated value from, and the updated value to. The function is to traverse the edges of the grid map, check if the value at the edge is equal to from, and then use a breadth-first search tool to change all connected from values ​​to to.

[0112] Traverse each row and check the values ​​of the first and last column positions. If the values ​​of these positions are from, call the breadth-first search tool to start filling from these positions.

[0113] Traverse each column and check the values ​​of the first and last row positions. If the values ​​of these positions are from, call the breadth-first search tool to start filling from these positions.

[0114] Breadth-first search tool

[0115] Pass in the grid map, starting from (i, j), and use the breadth-first search algorithm (mature algorithm) to fill all areas with values ​​from to to.

[0116] S23: Occupancy grid map builder;

[0117] refer to Figure 2 The occupancy grid diagram for the U-turn scenario shown in the figure initializes a two-dimensional array bin_map based on x_size and y_size, with each position set to 0;

[0118] Traverse all elements of bound_vec, read the two points before and after the traversal, pass them into the line segment rasterization tool, obtain the sequence of all grid points passing through the line connecting these two points, and set the position in bin_map represented by the grid point coordinates in this sequence to 1;

[0119] Call the edge fill tool to set all the parts from the grid boundary in bin_map to the bound_vec stored in the fusion of map lanes and perceived curb boundaries to 1;

[0120] Define a grid map obs_map with the same number of rows and columns as bin_map, with each position set to 0, specifically used to represent obstacles;

[0121] Traverse each obstacle in obs_vec, then traverse the contour points of each obstacle in the second layer, read the contour points before and after the traversal, pass them into the line segment rasterization tool, and obtain the sequence of all grid points passing through the line connecting these two points. Set the position represented by the grid point coordinates in this sequence in obs_map to 1;

[0122] Call the edge filling tool to set the portion from the grid boundary in obs_map to the obstacle outline boundary stored in obs_vec to 2;

[0123] Traverse obs_map and set the obstacle boundary and its interior to 1, and also set the outermost circle of obstacles to 1;

[0124] Traverse obs_map and find the position where obs_map is 1 and update bin_map to 1. Figure 3 The figure shows a schematic diagram of bin_map. The dark green grid represents the occupied part, which is represented by 1, and the rest represents the unoccupied part, which is represented by 0.

[0125] S24: prefix and raster map builder;

[0126] Define a grid map presum_map with the same number of rows and columns as bin_map, and set each position to 0;

[0127] Traverse presum_map and calculate presum_map[i][j]= bin_map[i - 1][j - 1] + bin_map[i- 1][j]+ bin_map[i][j - 1]-bin_map[i - 1][j - 1]. Figure 4 This is a schematic diagram of pre_sum_map. The dark green and non-dark green parts have the same meaning. The value of each grid previously represents the prefix sum, which is used to calculate collision detection.

[0128] S25: Euclidean distance field grid map builder;

[0129] Define a grid map esdf_map with the same number of rows and columns as bin_map, and set each position to 0. Initialize a double-ended queue dq and initialize dis=0;

[0130] Traverse esdf_map, and update esdf_map to -10 for occupied positions with a value of 1 in bin_map. For each unoccupied position, its value is updated to dis, and the grid point is added to dq;

[0131] When dq is not empty, enter the loop, pop out the first point in dq and check its adjacent points. If the adjacent point is in a non-occupied position, add it to the queue and set the value of its esdf_map position to the current distance dis. After each layer of dis is processed, the value increases by step. Figure 5 This is a schematic diagram of esdf_map. The value represents the distance from the grid to the nearest obstacle, so the dark green part is represented by a negative number, and the rest of the value increases the farther away from the obstacle.

[0132] S3: relevant functions that can be realized;

[0133] S31:IsPointOccupied;

[0134] Determine whether a Cartesian point is occupied;

[0135] Pass in a Cartesian point, get the grid coordinates through the coordinate converter, query the value of the grid coordinate in bin_map, and return it.

[0136] S32:IsAaBoxOccupied;

[0137] Determine whether an AABox is occupied;

[0138] Pass in the lower left and upper right points of the AABox, first use IsPointOccupied to determine whether these two points are occupied. If occupied, return directly, otherwise calculate the grid coordinates of the lower left point (x_min, y_min) and the upper right point (x_max, y_max), and use presum_map to calculate the sum of the area from (x_min, y_min) to (x_max, y_max) (hash method). If the sum is 0, it means it is not occupied, otherwise it means it is occupied, and return.

[0139] S33: GetPointMinDistanceToObstacle;

[0140] Calculate the distance from a Cartesian point to the nearest occupied position;

[0141] Pass in a Cartesian point, get the grid coordinates through the coordinate converter, query the value of the grid coordinate in esdf_map, and return it.

[0142] Therefore, the present invention proposes a local map construction method for path planning. Based on the reference line of the local map to be planned in the Frenet coordinate system, the preset map is traversed according to the perception information and map information to obtain the road boundary information and obstacle information of the local map to be planned; the road boundary information and obstacle information in the Cartesian system are converted into a grid map to construct an occupancy grid map of the local map to be planned; based on the occupancy grid map, a prefix grid map and a Euclidean distance field grid map of the local map to be planned are constructed; and path planning is performed based on the occupancy grid map, prefix grid map, and Euclidean distance field grid map of the local map to be planned to obtain the planned path of the local map to be planned. Planning and collision detection are performed within the local map constructed by the present invention. Autonomous driving does not have a strong need to compete with dynamic obstacles at the path planning level, and the frame rate of all mapping can be low to reduce computing power consumption.

[0143] Exemplary devices

[0144] Figure 6 FIG is a schematic diagram of a local map construction device for path planning provided by an exemplary embodiment of the present invention. Figure 6 As shown, the apparatus 600 includes:

[0145] A traversal module 610 is configured to traverse a preset map based on the reference line of the local map to be planned in the Frenet coordinate system according to the perception information and the map information to obtain road boundary information and obstacle information of the local map to be planned;

[0146] A first construction module 620 is configured to convert the road boundary information and obstacle information in the Cartesian system into a grid map, and construct an occupied grid map of the local map to be planned;

[0147] A second construction module 630 is configured to construct a prefix grid map and a Euclidean distance field grid map of the local map to be planned based on the occupancy grid map;

[0148] The planning module 640 is configured to perform path planning based on the occupancy grid map, the prefix grid map, and the Euclidean distance field grid map of the local map to be planned, and obtain a planned path for the local map to be planned.

[0149] Optionally, the traversal module 610 traverses the preset map to obtain road boundary information based on the reference line of the local map to be planned in the Frenet coordinate system according to the perception information and the map information, including:

[0150] Based on the reference line of the frenet coordinate system, customize the vertical starting point start_s and the vertical end point end_s;

[0151] Traverse all reference points between the starting point and the end point in the preset map, and read the first leftmost boundary point left_xy and the first rightmost boundary point right_xy of each reference point;

[0152] Read the second leftmost boundary point left_curb_xy and the second rightmost boundary point right_curb_xy of the longitudinal position corresponding to the left and right visual curb information of each reference point;

[0153] Update the first leftmost boundary point left_xy and the second leftmost boundary point left_curb_xy, whichever is closer to the lane center, to the new leftmost boundary point left_xy;

[0154] Update the first rightmost boundary point right_xy and the second rightmost boundary point right_curb_xy, which is closer to the lane center, to the new rightmost boundary point right_xy, and store the new leftmost boundary point left_xy and the new rightmost boundary point right_xy after each reference point is updated into the road boundary container bound_vec to obtain the road boundary information.

[0155] Optionally, the traversal module 610 traverses the preset map to obtain obstacle information based on the reference line of the local map to be planned in the Frenet coordinate system according to the perception information and the map information, including:

[0156] Traverse all reference points between the longitudinal starting point start_s and the longitudinal end point end_s;

[0157] Determine the left boundary position left_lim_l and the right boundary position right_lim_l of the widest point in this longitudinal interval according to the left boundary left_l and the right boundary right_l of each reference point;

[0158] Traverse all static obstacles provided by the perception function, filter out obstacles that are completely outside the longitudinal start point start_s and the longitudinal end point end_s, and obstacles that are completely outside the left boundary position left_lim_l and the right boundary position right_lim_l, and store the remaining obstacles that meet the requirements after filtering into the obstacle container obs_vec to obtain obstacle information.

[0159] Optionally, the first building block 620 includes:

[0160] Traverse the road boundary information and obtain the four extreme positions to determine the local map boundary in the Cartesian system;

[0161] Define the grid resolution step, x-axis grid number, y-axis grid number, and Cartesian origin coordinates of the grid map based on the local map boundary;

[0162] Initialize the two-dimensional array bin_map, setting each position to 0;

[0163] Traverse all elements in the obstacle information bound_vec, use the line segment rasterization tool to read all the first grid point sequences passing through the line connecting the two points before and after the traversal, and set the positions in the two-dimensional array bin_map represented by the grid point coordinates in all the first grid point sequences to 1;

[0164] Call the edge fill tool to set all the parts from the grid boundary in the two-dimensional array bin_map to the obstacle information bound_vec stored in the fusion of the map lane and the perception roadside boundary to 1;

[0165] Define the first grid map obs_map with the same number of rows and columns as the two-dimensional array bin_map to represent obstacles, and set each position to 0;

[0166] Traverse each obstacle in the first grid map obs_vec, then traverse the contour points of each obstacle in the second layer, use the line segment rasterization tool to read all the second grid point sequences passing through the line connecting the two contour points before and after the traversal, and set the positions in the first grid map obs_map represented by the grid point coordinates of all the second grid point sequences to 1;

[0167] Call the edge filling tool to set the portion between the grid boundary in the first grid map obs_map and the obstacle outline boundary stored in the obstacle information obs_vec to 2;

[0168] Traverse the first grid map obs_map and set the obstacle boundary and its interior to 1, and also set the outermost circle of obstacles to 1;

[0169] Traverse the first grid map obs_map, find the position where the grid map obs_map is 1, and update the two-dimensional array bin_map to 1, and build the occupied grid map of the local map to be planned.

[0170] Optionally, the line segment rasterization tool is implemented as follows:

[0171] Input the first starting point start and the first end point end in the Cartesian system, and output the grid point container vx_vec that stores all the grid points that need to be passed from the first starting point start to the first end point end in the grid map;

[0172] Get the vector ray={end[0] - start[0], end[1] - start[1]} formed by the first starting point start and the first end point end of Cartesian. Calculate the line segment according to the vector ray x and y The moving direction on the axis dir={ray[0]>0?1:-1, ray[1]>0?1:-1}, where the moving directions include: {1, 1}, {1, -1}, {-1, 1} and {-1, -1};

[0173] According to the second starting point start_vx and the second end point end_vx of the grid map obtained by the coordinate converter and the moving direction, the grid point is moved in the x-axis and y-axis directions by one grid resolution step and converted into Cartesian coordinates n_vx={(start_vx[0]+ (dir[0]>0)) * step + base[0], (end_vx[1]+ (di[1]>0)) * step + base[1]};

[0174] According to the Cartesian coordinate point set, initialize t_max={abs((n_vx[0] - start_vx[0]) / ray[0]), abs((n_vx[1] - start_vx[1]) / ray[1])} and t_step={abs(step / ray[0]* dir[0]), abs(step / ray[1]* dir[1])}, where t_max is used to record the time interval to reach the next grid, and t_step is the time increment of each step;

[0175] Add the second starting point start_vx of the grid map to the grid point container vx_vec, define the grid point cur_vx to be initialized as the second starting point start_vx, and if cur_vx has not moved to the second end point end_vx, enter a loop to determine the size of the x-axis and y-axis data in t_max. If the x-axis direction is smaller, t_max[0] += t_step[0] and curr_vx[0]+= di[0] to achieve movement in the x-axis direction, otherwise it will achieve movement in the y-axis direction. After the movement is completed, add the moved grid point cur_vx to the grid point container vx_vec.

[0176] Optionally, the edge filling tool is implemented as follows:

[0177] Traverse the edge of the initial grid map, check whether the value of the edge position is equal to from, and change all connected original values ​​from to the target value to through the breadth-first search tool, where

[0178] Traverse the edges of the initial grid map, check whether the value of the edge position is equal to the original value from, and change all connected original values ​​from to the target value to through the breadth-first search tool, including:

[0179] Traverse each row of the initial grid map, check multiple first values ​​at the first and last column positions, and if multiple first values ​​are the original value from, call the breadth-first search tool starting from the first and last column positions to fill the original value from with the target value to;

[0180] Traverse each column of the initial grid map, check the multiple second values ​​at the first and last rows, and if the multiple second values ​​are from, call the breadth-first search tool starting from the first and last rows to fill the original value from with the target value to.

[0181] Optionally, the second construction module 630 constructs a prefix grid map of the local map to be planned based on the occupied grid map, including:

[0182] Define a second grid map with the same number of rows and columns as the two-dimensional array, where each position of the second grid map is set to 0;

[0183] The value of each grid point in the second grid map is calculated based on the occupied grid map to obtain the prefix grid map. The calculation formula for the value of each grid point in the second grid map is:

[0184] presum_map[i][j]= bin_map[i - 1][j - 1]+ bin_map[i - 1][j] + bin_map[i][j - 1] -bin_map[i- 1][j - 1], where bin_map is the occupied grid map.

[0185] Optionally, the second construction module 630 constructs a Euclidean distance field grid map of the local map to be planned based on the occupancy grid map, including:

[0186] Define a third grid map with the same number of rows and columns as the two-dimensional array, where each position in the third grid map is set to 0; and initialize a double-ended queue dq and the distance dis from a position to its nearest obstacle to 0;

[0187] Update the position of the occupied position corresponding to 1 in the occupied grid map to -10 in the third grid map, update the position of the unoccupied position corresponding to the occupied grid map to the distance dis in the third grid map, and add the grid point of the unoccupied position to the double-ended queue dq;

[0188] When the double-ended queue dq is not empty, a loop is entered, the first point in the double-ended queue dq is popped out to check its adjacent points. If the adjacent point is in a non-occupied position, it is added to the double-ended queue dq, and the value of its position in the third grid map is set to the current distance dis. After each layer of distance dis value is processed, the grid resolution is increased until all grid points in the third grid map are assigned values, and the Euclidean distance field grid map of the local map to be planned is constructed.

[0189] Optionally, the planning module 640 includes:

[0190] Evaluate the points in the initial planning path preset and constructed in the local map to be planned according to the occupancy grid map, and update the initial planning path according to the evaluation result to obtain a first updated planning path;

[0191] Evaluate the rectangles in the first updated planned path according to the prefix grid map, and update the first updated planned path according to the evaluation result to obtain a second updated planned path;

[0192] The distances from points in the second updated planned path to obstacles are evaluated according to the prefix grid map, and the second updated planned path is updated according to the evaluation result to obtain a planned path of the local map to be planned.

[0193] Exemplary electronic devices

[0194] Figure 7 This is the structure of an electronic device provided by an exemplary embodiment of the present invention. Figure 7 As shown, the electronic device 70 includes one or more processors 71 and a memory 72 .

[0195] The processor 71 may be a central processing unit (CPU) or other forms of processing units having data processing capabilities and / or instruction execution capabilities, and may control other components in the electronic device to perform desired functions.

[0196] The memory 72 may include one or more computer program products, which may include various forms of computer-readable storage media, such as volatile memory and / or non-volatile memory. The volatile memory may include, for example, random access memory (RAM) and / or cache memory. The non-volatile memory may include, for example, read-only memory (ROM), a hard disk, flash memory, etc. One or more computer program instructions may be stored on the computer-readable storage medium, and the processor 71 may execute the program instructions to implement the software program methods and / or other desired functions of the various embodiments of the present invention described above. In one example, the electronic device may further include: an input device 73 and an output device 74, these components being interconnected via a bus system and / or other form of connection mechanism (not shown).

[0197] In addition, the input device 73 may also include, for example, a keyboard, a mouse, and the like.

[0198] The output device 74 can output various information to the outside. The output device 74 can include, for example, a display, a speaker, a printer, a communication network and a remote output device connected thereto.

[0199] Of course, to simplify, Figure 7 Only some of the components related to the present invention in the electronic device are shown, and components such as a bus, an input / output interface, etc. are omitted. In addition, the electronic device may further include any other appropriate components according to specific application conditions.

[0200] Exemplary computer program products and computer-readable storage media

[0201] In addition to the above-mentioned methods and devices, an embodiment of the present invention may also be a computer program product, which includes computer program instructions, which, when executed by a processor, enable the processor to perform the steps of the method according to various embodiments of the present invention described in the above "Exemplary Method" section of this specification.

[0202] The computer program product may be written in any combination of one or more programming languages ​​to implement the operations of embodiments of the present invention, including object-oriented programming languages ​​such as Java, C++, and conventional procedural programming languages ​​such as C or similar programming languages. The program code may be executed entirely on the user's computing device, partially on the user's computing device, as a stand-alone software package, partially on the user's computing device and partially on a remote computing device, or entirely on a remote computing device or server.

[0203] In addition, an embodiment of the present invention may also be a computer-readable storage medium having computer program instructions stored thereon, which, when executed by a processor, enable the processor to execute the steps of the method according to various embodiments of the present invention described in the above "Exemplary Method" section of this specification.

[0204] The computer-readable storage medium may be any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium may include, for example, but is not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, system, or device, or any combination thereof. More specific examples (a non-exhaustive list) of readable storage media include: an electrical connection having one or more wires, a portable disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof.

[0205] The basic principles of the present invention have been described above in conjunction with specific embodiments. However, it should be noted that the advantages, strengths, and effects mentioned in the present invention are merely illustrative and non-limiting, and should not be construed as necessarily possessed by each embodiment of the present invention. Furthermore, the specific details disclosed above are provided for illustrative purposes and to facilitate understanding, and are not intended to be limiting. These details do not necessarily limit the present invention to being implemented using these specific details.

[0206] Each embodiment in this specification is described in a progressive manner, with each embodiment focusing on its differences from the other embodiments. References to the same or similar parts between the various embodiments are sufficient. For system embodiments, since they largely correspond to method embodiments, their description is relatively simple. For relevant parts, references to the description of the method embodiments are sufficient.

[0207] The block diagrams of the devices, systems, equipment, and systems involved in the present invention are merely illustrative examples and are not intended to require or imply that they must be connected, arranged, or configured in the manner shown in the block diagrams. As will be appreciated by those skilled in the art, these devices, systems, equipment, and systems can be connected, arranged, or configured in any manner. Words such as "including," "comprising," "having," and the like are open-ended words, meaning "including but not limited to," and can be used interchangeably therewith. The words "or" and "and" used herein refer to the words "and / or" and can be used interchangeably therewith, unless the context clearly indicates otherwise. The word "such as" used herein refers to the phrase "such as but not limited to," and can be used interchangeably therewith.

[0208] The method and system of the present invention may be implemented in many ways. For example, the method and system of the present invention may be implemented by software, hardware, firmware, or any combination of software, hardware, and firmware. The above sequence of steps for the method is for illustration only, and the steps of the method of the present invention are not limited to the sequence specifically described above, unless otherwise specified. In addition, in some embodiments, the present invention may also be implemented as a program recorded in a recording medium, which includes machine-readable instructions for implementing the method according to the present invention. Thus, the present invention also covers recording media that store programs for executing the method according to the present invention.

[0209] It should also be noted that, in the system, device and method of the present invention, each component or each step can be decomposed and / or recombined. These decompositions and / or recombinations should be regarded as equivalent schemes of the present invention. The above description of the disclosed aspects is provided to enable any technician in this field to make or use the present invention. Various modifications to these aspects will be very obvious to those skilled in the art, and the general principles defined here can be applied to other aspects without departing from the scope of the present invention. Therefore, the present invention is not intended to be limited to the aspects shown here, but according to the widest scope consistent with the principles disclosed here and novel features.

[0210] The above description has been presented for purposes of illustration and description. Furthermore, this description is not intended to limit the embodiments of the present invention to the forms disclosed herein. Although a number of example aspects and embodiments have been discussed above, those skilled in the art will recognize certain variations, modifications, alterations, additions, and sub-combinations thereof.

Claims

1. A local map construction method for path planning, characterized in that: include: Based on the reference line of the local map to be planned in the frenet coordinate system, traverse the preset map according to the perception information and the map information to obtain the road boundary information and obstacle information of the local map to be planned; Adding the road boundary information and the obstacle information to the constructed Cartesian system, and converting the road boundary information and the obstacle information under the Cartesian system into a grid map, to construct an occupied grid map of the local map to be planned; Based on the occupancy grid map, construct a prefix grid map and a Euclidean distance field grid map of the local map to be planned; wherein the prefix grid map and the Euclidean distance field grid map have the same number of rows and columns as the two-dimensional array of the occupancy grid map; Based on the occupancy grid map, constructing the prefix grid map comprises: Traversing the grid points and adjacent grid points in the occupied grid map to obtain a value of each grid point in the prefix grid map; Based on the occupancy grid map, constructing the Euclidean distance field grid map comprises: updating the corresponding position in the Euclidean distance field grid map according to the occupied position in the occupied grid map, and updating the corresponding position in the Euclidean distance field grid map according to the unoccupied position in the occupied grid map and the distance dis from a certain position to its nearest obstacle; Path planning is performed according to the occupied grid map, the prefix grid map, and the Euclidean distance field grid map of the local map to be planned, so as to obtain a planned path of the local map to be planned.

2. The method according to claim 1, characterized in that The reference line of the local map to be planned in the frenet coordinate system traverses the preset map to obtain road boundary information according to the perception information and map information, including: Based on the reference line of the frenet coordinate system, customize the longitudinal starting point start_s and the longitudinal end point end_s; Traverse all reference points between the starting point and the end point in the preset map, and read the first leftmost boundary point left_xy and the first rightmost boundary point right_xy of each reference point; Read the second leftmost boundary point left_curb_xy and the second rightmost boundary point right_curb_xy of the longitudinal position corresponding to the left and right visual curb information of each reference point; Update the first leftmost boundary point left_xy and the second leftmost boundary point left_curb_xy, whichever is closer to the center of the lane, to the new leftmost boundary point left_xy; The first rightmost boundary point right_xy and the second rightmost boundary point right_curb_xy, which is closer to the lane center, is updated as a new rightmost boundary point right_xy, and the new leftmost boundary point left_xy and the new rightmost boundary point right_xy after each reference point is updated are stored in the road boundary container bound_vec to obtain the road boundary information.

3. The method according to claim 2, characterized in that The reference line of the local map to be planned in the frenet coordinate system traverses the preset map to obtain obstacle information according to the perception information and map information, including: Traverse all reference points between the longitudinal starting point start_s and the longitudinal end point end_s; Determine the left boundary position left_lim_l and the right boundary position right_lim_l of the widest part in this longitudinal interval according to the left boundary left_l and the right boundary right_l of each reference point; Traverse all static obstacles provided by perception, filter out obstacles completely outside the longitudinal start point start_s and the longitudinal end point end_s, and obstacles completely outside the left boundary position left_lim_l and the right boundary position right_lim_l, store the remaining obstacles that meet the requirements after filtering into the obstacle container obs_vec, and obtain the obstacle information.

4. The method according to claim 1, characterized in that Converting the road boundary information and the obstacle information in the Cartesian system into a grid map, and constructing an occupied grid map of the local map to be planned, including: Traversing the road boundary information, obtaining four extreme positions to determine the local map boundary in a Cartesian system; Define the grid resolution step, x-axis grid number, y-axis grid number and Cartesian origin coordinates of the grid map according to the local map boundary; Initialize the two-dimensional array bin_map, setting each position to 0; Traverse all elements in the obstacle information bound_vec, use the line segment rasterization tool to read all first grid point sequences passing through the line connecting the two points before and after the traversal, and set the positions in the two-dimensional array bin_map represented by the grid point coordinates in all first grid point sequences to 1; Calling the edge filling tool to set all the parts from the grid boundary in the two-dimensional array bin_map to the boundary of the obstacle information bound_vec that integrates the map lane and the perceived roadside boundary to 1; Define a first grid map obs_map with the same number of rows and columns as the two-dimensional array bin_map to represent obstacles, and set each position to 0; Traverse each obstacle in the first grid map obs_vec, and then traverse the contour points of each obstacle in the second layer, use the line segment rasterization tool to read all the second grid point sequences passing through the line connecting the two contour points before and after the traversal, and set the positions in the first grid map obs_map represented by the coordinates of the grid points in all the second grid point sequences to 1; Calling the edge filling tool to set all the portions from the grid boundary in the first grid map obs_map to the obstacle contour boundary stored in the obstacle information obs_vec to 2; Traverse the first grid map obs_map, set the obstacle boundary and its interior to 1, and also set the outermost circle of the obstacle to 1; The first grid map obs_map is traversed to find out the position where the grid map obs_map is 1 and the corresponding position is updated to 1 in the two-dimensional array bin_map, so as to construct the occupied grid map of the local map to be planned.

5. The method according to claim 4, characterized in that The implementation process of the edge filling tool is as follows: Traverse the edge of the initial grid map, check whether the value of the edge position is equal to from, and use the breadth-first search tool to change all connected original values ​​from to the target value to, where Traverse the edge of the initial grid map, check whether the value of the edge position is equal to the original value from, and change all connected original values ​​from to the target value to through a breadth-first search tool, including: Traversing each row of the initial grid map, checking multiple first values ​​at the first column and the last column, if the multiple first values ​​are the original value from, calling a breadth-first search tool to fill the original value from with the target value to starting from the first column and the last column; Each column of the initial grid map is traversed to check the multiple second values ​​at the first row and the last row. If the multiple second values ​​are from, a breadth-first search tool is called to fill the original value from with the target value to starting from the first row and the last row.

6. The method according to claim 4, characterized in that According to the occupied positions in the occupied grid map, the corresponding positions in the Euclidean distance field grid map are updated, and according to the unoccupied positions in the occupied grid map and the distance dis from a certain position to its nearest obstacle, the corresponding positions in the Euclidean distance field grid map are updated, including: Define a third grid map with the same number of rows and columns as the two-dimensional array, set each position of the third grid map to 0; and initialize a double-ended queue dq and a distance dis from a certain position to its nearest obstacle to 0; Update the occupied position corresponding to 1 in the occupied grid map to -10 in the third grid map, update the unoccupied position corresponding to the position in the third grid map to the distance dis, and add the grid point of the unoccupied position to the double-ended queue dq; When the double-ended queue dq is not empty, a loop is entered, the first point in the double-ended queue dq is popped out to check its adjacent points. If the adjacent point is in a non-occupied position, it is added to the double-ended queue dq, and the value of its position in the third grid map is set to the current distance dis. After each layer of distance dis value is processed, the grid resolution is increased until all grid points of the third grid map are assigned values, and the Euclidean distance field grid map of the local map to be planned is constructed.

7. The method according to claim 1, characterized in that Performing path planning according to the occupied grid map, the prefix grid map, and the Euclidean distance field grid map of the local map to be planned to obtain a planned path of the local map to be planned, including: Evaluate points in an initial planning path preset and constructed in the local map to be planned according to the occupancy grid map, and update the initial planning path according to the evaluation result to obtain a first updated planning path; Evaluate the rectangles in the first updated planned path according to the prefix grid map, and update the first updated planned path according to the evaluation result to obtain a second updated planned path; The distances from points in the second updated planned path to obstacles are evaluated according to the prefix grid map, and the second updated planned path is updated according to the evaluation result to obtain the planned path of the local map to be planned.

8. A local map construction device for path planning, characterized in that: include: A traversal module, used to traverse a preset map based on a reference line of a local map to be planned in a frenet coordinate system according to perception information and map information to obtain road boundary information and obstacle information of the local map to be planned; A first construction module is used to add the road boundary information and the obstacle information to the constructed Cartesian system, and convert the road boundary information and the obstacle information under the Cartesian system into a grid map, so as to construct an occupied grid map of the local map to be planned; A second construction module is used to construct a prefix grid map and a Euclidean distance field grid map of the local map to be planned based on the occupancy grid map; wherein the prefix grid map and the Euclidean distance field grid map have the same number of rows and columns as the two-dimensional array of the occupancy grid map; Based on the occupancy grid map, constructing the prefix grid map comprises: Traversing the grid points and adjacent grid points in the occupied grid map to obtain a value of each grid point in the prefix grid map; Based on the occupancy grid map, constructing the Euclidean distance field grid map comprises: updating the corresponding position in the Euclidean distance field grid map according to the occupied position in the occupied grid map, and updating the corresponding position in the Euclidean distance field grid map according to the unoccupied position in the occupied grid map and the distance dis from a certain position to its nearest obstacle; A planning module is used to perform path planning according to the occupied grid map, the prefix grid map and the Euclidean distance field grid map of the local map to be planned, so as to obtain a planned path of the local map to be planned.

Images