Occupying grid map generation method and device and storage medium

Abstract

The application discloses an occupancy grid map generation method and device and a storage medium, relates to the technical field of robot navigation training data generation, and comprises the following steps: loading a programmatically generated three-dimensional simulation scene; traversing all graphics elements, matching the name, semantic label and reference asset path of the graphics element with a preset keyword set, and determining a target graphics element; generating a solid collision proxy that participates in physical collision and does not participate in rendering at the world pose of the target graphics element; defining a scanning range based on a tile graphics element, and scanning voxels in a robot preset passage height slice to obtain an occupancy grid and a free grid; selecting a free grid seed with the centroid of the occupancy grid as a reference point, performing four-connected flooding on adjacent free grids, and outputting a three-value grid map of occupancy, freedom and unknown. According to the application, open obstacles and ground props that lack collision bodies can be scanned and perceived without destroying instantiation structures and polluting rendering data, and the accuracy of the occupancy grid map is improved.

Description

Technical Field

[0001] This invention relates to the field of robot navigation training data generation technology, and in particular to a method, apparatus and storage medium for generating occupancy grid maps. Background Technology

[0002] With the development of autonomous mobile robots, end-to-end navigation models, and embodied intelligence training technologies, generating large-scale navigation training data based on simulation environments has become an important data acquisition method. To improve scene diversity and reduce the cost of manual modeling, existing technologies typically employ procedural scene generation methods to construct 3D simulation scenes. For example, different layouts of warehouses, factories, and indoor passageways are generated through tile assembly, rule constraints, or random seeds, and obstacles or ground props such as shelves, walls, traffic cones, forklifts, and warning signs are placed within these scenes.

[0003] In existing simulation platforms, the commonly used method for generating occupied grid maps is voxel scanning. This method typically performs voxel-based detection on the 3D scene within a user-specified spatial range and height slice, and determines whether a grid is occupied based on collision geometry from the physics engine. However, this type of method depends on whether scene primitives are configured with physical colliders. For visible geometry without configured colliders, even if it exists in the rendered image, it may not be detected by the voxel scanning tool, resulting in missing obstacles in the generated occupied grid map.

[0004] The aforementioned problems are particularly prominent in procedurally generated 3D simulation scenes. To reduce memory usage and loading overhead, primitives such as tiles, shelves, and props in the scene are often assembled using instantiation, with the same source asset being shared by multiple instances. Meanwhile, many visual assets lack physical colliders, or the primitives within instance proxies are in a read-only state, making individual modification difficult. In such cases, directly using existing voxel scanning tools to generate an occupied raster map may result in problems such as an approximately empty map, missing obstacles, or unrecorded ground props.

[0005] To address the issue of missing colliders in instantiated scenes, one possible solution is to add collision attributes to the instance root or related primitives, enabling the physics engine to generate collision geometry data for collision detection based on the geometric data of the instance root or related primitives. However, for open obstacles, such as shelves and racks, their actual geometry typically consists of thin columns, beams, and thin panels. Within the robot's passage height slice, only scattered small structures are often scanned, causing the shelves to appear as sparse points in the graph. The path planner may incorrectly assume that the interior of the shelves is passable, thus planning a path through the shelves.

[0006] Another solution is to uniformly approximate obstacles using convex hulls or solid shapes to enhance their occupancy effect. However, if this approach is applied indiscriminately to large structural objects such as walls, it can easily misfill actually passable areas as occupied areas, resulting in an overly closed map and reduced navigation usability. Therefore, existing solutions struggle to simultaneously meet the requirements of solid representation for open obstacles and accurate representation of wall structures.

[0007] Another approach is to deinstantiate the instantiated geometry as a whole and then add collision attributes or semantic information to each internal mesh individually. However, deinstantiation disrupts the instance sharing mechanism, significantly increases memory usage and loading time, and may alter the original scene structure, which is detrimental to the batch generation and reuse of large-scale procedural scenes.

[0008] Furthermore, existing occupancy map generation schemes typically require manual specification of the scan range or direct determination of the scan range based on the entire scene bounding box. In procedural scenes, there may be outliers, anomalously transformed tiles, or scale-distorted primitives far from the main area. Including these in the scan range would significantly enlarge the map area, generating numerous invalid regions and increasing storage and path planning computational overhead. Even if voxel scanning yields free areas, empty or unreachable areas outside the scene may be mistakenly marked as free space, affecting robot initialization, path planning, and drivability determination.

[0009] Furthermore, randomly placed ground props in procedural scenarios may also be missing from the occupation grid map due to a lack of colliders or incorrect representation. Since path planning and automatic collision reset typically rely on the same occupation map, missing props can cause the robot to plan a path through them. When the robot actually collides with a prop, the system may fail to trigger the correct non-accessible determination because the obstacle is not recorded in the map, causing the data acquisition process to stall and requiring manual intervention.

[0010] Therefore, there is an urgent need for an occupation grid map generation method that can automatically generate an occupation grid map with accurate obstacle representation, compact scan range, and reliable free space for procedural 3D simulation scenes with instantiated references and a lack of physical colliders in the source assets, without destroying the instantiated structure, modifying the source assets, or polluting the rendering training data. Summary of the Invention

[0011] This application aims to at least partially address one of the technical problems in the related art. To this end, one objective of this application is to propose an occupancy grid map generation method, apparatus, and storage medium that can automatically generate an occupancy grid map with accurate obstacle representation, compact scan range, and reliable free space without destroying the instantiation structure, modifying the source assets, or polluting the rendering training data.

[0012] To achieve the above objectives, a first aspect of this application proposes a method for generating occupied grid maps. The method includes: loading a procedurally generated 3D simulation scene; traversing all primitives in the 3D simulation scene, matching the name, semantic tag, and reference asset path of each primitive with a preset keyword set, and determining target primitives based on the matching results; generating solid collision proxies that participate in physical collisions but do not participate in rendering at the world pose of each target primitive, so as to supplement the target primitives with collision geometry that can be perceived by voxel scanning in the physics engine; defining the scanning range based on the tile primitives in all primitives, performing voxel scanning on the scanning range within a preset passage height slice of the robot, and obtaining occupied grids and idle grids; using the centroid of all occupied grids as a reference point, taking the idle grid closest to the reference point as a seed, performing a four-connectivity flooding to adjacent idle grids, marking the idle grids traversed by the flooding as free grids, and marking the idle grids not traversed by the flooding as unknown grids, and outputting a ternary grid map.

[0013] In some embodiments, the step of matching the name, semantic tag, and reference asset path of each graphic element with a preset keyword set and determining the target graphic element based on the matching result includes: matching the name, semantic tag, and reference asset path of the graphic element with the preset keyword set as channels respectively; if any channel is successfully matched, the graphic element is determined as the target graphic element.

[0014] In some embodiments, the preset keyword set is obtained by: traversing the primitives in the three-dimensional simulation scene, extracting the names, semantic tags, and reference asset paths of the primitives located within the robot's travel height range; determining keywords that match preset open obstacles and / or preset ground props based on the distribution of the extracted names, semantic tags, and reference asset paths, and writing them into the preset keyword set.

[0015] In some embodiments, before generating solid collision proxies that participate in physical collisions but do not participate in rendering at the world pose of each of the target primitives, the method further includes: calculating the horizontal projected area of ​​each of the target primitives; and using target primitives whose horizontal projected area does not exceed a preset upper limit as target primitives that have passed the verification.

[0016] In some embodiments, the preset upper limit is greater than or equal to the horizontal projected area of ​​the largest legal obstacle unit in the three-dimensional simulation scene, and less than the horizontal projected area of ​​the structural component in the three-dimensional simulation scene.

[0017] In some embodiments, defining the scanning range based on tile primitives among all primitives includes: selecting tile primitives from all primitives according to a preset tile naming pattern; calculating the bounding box of each tile primitive, and removing tile primitives whose bounding box side length exceeds a distortion threshold; taking the union of the bounding boxes of the remaining tile primitives and expanding them outward by a preset margin to obtain the scanning range.

[0018] In some embodiments, the method further includes: outputting the ternary grid map to a data acquisition system, so that the data acquisition system expands the occupied grids in the ternary grid map according to the ternary grid map and the robot's external dimensions, and generates path planning grids and accessibility determination grids.

[0019] In some embodiments, at least some primitives in the 3D simulation scene are assembled by instantiation and reference, and the source assets of the at least some primitives are not configured with physical colliders.

[0020] To achieve the above objectives, a second aspect of this application provides an occupancy grid map generation apparatus, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the occupancy grid map generation method described in the first aspect of this application.

[0021] To achieve the above objectives, a third aspect of this application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the occupancy grid map generation method described in the first aspect of this application.

[0022] According to the occupied grid map generation method, apparatus and storage medium of the present application embodiments, after loading the procedurally generated 3D simulation scene, the target primitive is automatically identified based on the primitive name, semantic label and reference asset path; then, a solid collision proxy that only participates in physical collision and does not participate in rendering is generated at the world pose of the target primitive; then, the scanning range is automatically defined based on the tile primitive, voxel scanning is performed within the robot passage height slice, and the idle grid is further divided into free grid and unknown grid by four-connectivity flooding, and finally a ternary grid map is output.

[0023] Therefore, this application enables open obstacles and ground props with insufficient collision volume or sparse collision representation to be correctly perceived by voxel scanning without destroying the instantiated scene structure, modifying the source assets, or polluting the rendering data; at the same time, it reduces invalid map sheets by limiting tile range and avoids misjudging unreachable empty areas as free space by flooding connected domains, thereby improving the accuracy of obstacle representation, map sheet compactness, and the reliability of free space in the grid map.

[0024] The advantages of this application in terms of its additional aspects will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0025] Figure 1 This is a flowchart illustrating the method for generating an occupied grid map according to an embodiment of this application; Figure 2 This is a schematic flowchart illustrating the process of defining the scanning range based on tile primitives in an embodiment of this application. Figure 3 This is a structural block diagram of the grid map generation apparatus according to an embodiment of this application. Detailed Implementation

[0026] The embodiments of this application are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this application, and should not be construed as limiting this application.

[0027] The following description, with reference to the accompanying drawings, outlines an embodiment of an occupational grid map generation method, apparatus, and storage medium.

[0028] This application provides a method for generating occupancy grid maps, applicable to procedurally generated 3D simulation scenes. The 3D simulation scene can be a warehouse, factory area, indoor corridor, shelving area, or other mobile robot navigation simulation scene. At least some primitives in the scene can be assembled through instantiation, for example, formed by combining assets such as floor tiles, wall tiles, shelves, stacks, and ground props. Because some source assets lack physical colliders, or the primitives within the instance proxy lack collision geometry that can be perceived by the physics engine, directly using a voxel-based occupancy map tool can easily lead to problems such as missing obstacles, sparse occupancy of open obstacles, excessively large scanning range, and misjudgment of free space.

[0029] The occupation grid map generation method of this application embodiment utilizes the characteristic that the rendering pipeline and the physical pipeline are separated in the simulation platform. Without changing the source assets, destroying the instantiation structure, or affecting the rendering results, it supplements the specific obstacle target with invisible solid collision proxy bodies that can be perceived by voxel scanning, and then generates a ternary grid map based on voxel scanning and connected component flooding.

[0030] In some embodiments, such as Figure 1 As shown, the method for generating an occupied grid map according to an embodiment of this application includes: S1, load the procedurally generated 3D simulation scene.

[0031] Specifically, the local asset root path of the simulation platform is first set so that instantiated reference assets in the 3D simulation scene can be correctly resolved by the simulation platform. Then, the 3D simulation scene generated by the procedural scene generation tool can be correctly loaded. The procedural scene generation tool can generate scenes based on tile assembly methods, such as generating warehouse tile layouts based on wave function collapse algorithms, and randomly placing objects such as shelves, stacks, bins, traffic cones, forklifts, and wetland warning signs in the scene.

[0032] In an optional embodiment, after loading the 3D simulation scene, residual physical states in the scene can be cleared to avoid interfering with the generation of subsequent collision geometry. For instantiated primitives, collision attributes can also be applied to editable instance root primitives in the manner already available on the simulation platform, enabling the physics engine to generate collision geometry data for collision detection based on the geometric data of the instance prototype. This processing can serve as the basis for subsequent voxel scanning and allows structural components such as walls to maintain a relatively accurate thin-wall collision characterization without requiring overall deinstantiation or modification of the source asset itself.

[0033] S2 traverses all primitives in the 3D simulation scene, matches the name, semantic label, and referenced asset path of each primitive with a preset keyword set, and determines the target primitive based on the matching results.

[0034] Specifically, primitives can be nodes, meshes, instance roots, instance proxies, visible geometry, or other scene objects that can be managed by the simulation platform in a 3D simulation scene. The name of a primitive can be its path name or node name in the scene graph; the semantic label can be the category label of the primitive; and the referenced asset path can be the model file path or prototype path referenced by the primitive.

[0035] In an optional embodiment, for primitives assembled using instantiation references, if the primitives within an instance proxy are in a read-only state, the semantic tags or referenced asset paths of the primitives within the instance proxy can be read through the instance proxy without modifying the internal structure of the instance proxy. Thus, semantic information for identifying open obstacles and ground props can be obtained while preserving the instantiation sharing mechanism.

[0036] The pre-defined keyword set can include keywords used to characterize open obstacles and / or ground props. Open obstacles can include shelves, racks, stacks, bins, etc.; ground props can include traffic cones, forklifts, wetland warning signs, etc. Keywords can be Chinese names, English names, asset path fragments, semantic category identifiers, or combinations thereof.

[0037] In an optional embodiment, during the matching process, the name, semantic tag, and referenced asset path of a graphic element are used as channels to match a preset set of keywords. If any channel matches successfully, the graphic element is identified as the target graphic element. Therefore, even if the name of a graphic element is incomplete, it can still be identified through its semantic tag or referenced asset path; even if the semantic tag is missing, it can still be identified through its name or referenced asset path, thereby improving the reliability of target graphic element identification.

[0038] In one optional embodiment, the preset keyword set can be obtained through a reverse lookup of the scene primitive list. Specifically, the primitives in the 3D simulation scene can be traversed first to extract the names, semantic tags, and referenced asset paths of the primitives located within the robot's travel height range. Then, based on the distribution of the extracted names, semantic tags, and referenced asset paths, keywords corresponding to preset open obstacles and / or preset ground props can be determined and written into the preset keyword set. The preset keyword set can be saved as a configurable parameter. When using different asset libraries or different scene templates, the keyword set can be recalibrated without changing the grid map generation method itself.

[0039] S3 generates solid collision proxies at the world pose of each target primitive that participate in physical collisions but do not participate in rendering, in order to supplement the target primitives with collision geometry that can be perceived by voxel scanning in the physics engine.

[0040] Specifically, world transformation information of the target primitive can be obtained, and a solid collision proxy body can be created at the world pose corresponding to the target primitive. The solid collision proxy body can be a cuboid, cylinder, capsule, or other collision geometry that can cover the horizontal projection range of the target primitive. In one embodiment, the solid collision proxy body is a cuboid, whose horizontal dimension covers the horizontal projection range of the target primitive, and whose vertical direction covers a preset passage height slice of the robot.

[0041] The preset access height slice can be determined based on the robot's geometry, sensor height, or navigation map generation requirements. For example, in one embodiment, the preset access height slice can be between 0.1 meters and 0.62 meters. For open obstacles such as shelves, although their actual geometry may only include thin pillars and beams within this height slice, solid collision surrogates can form continuous occupied geometry in the physics engine, allowing the voxel scan results to characterize the entire shelf as an impassable area.

[0042] In an optional embodiment, a solid collision proxy is configured to participate only in physical collisions and not in rendering. Specifically, the rendering purpose of the solid collision proxy can be marked as not participating in rendering, while collision attributes are applied to the solid collision proxy. The solid collision proxy can be perceived by the voxel scanning tool through the physics engine, but will not appear in training data such as RGB images, semantic segmentation maps, or depth maps.

[0043] Since the rendering pipeline and physics pipeline in the simulation platform can be independent of each other, and the voxel-scanning occupancy grid map generation tool mainly determines whether a grid is occupied based on the collision geometry in the physics engine, and the rendered images in the training data are mainly generated by visible geometry, obstacle representations in the occupancy grid map can be corrected without changing the visible appearance of the scene by generating solid collision proxies that do not participate in rendering.

[0044] In an optional embodiment, the generated solid collision proxies can be uniformly placed under an independent group path in the 3D simulation scene, which is separate from the original scene primitives. This allows for easy deletion, reconstruction, or debugging of solid collision proxies without modifying the source assets or disrupting the original instantiation reference structure.

[0045] In an optional embodiment, the horizontal projected area of ​​the target primitives can be verified before generating the solid collision proxy. Specifically, the horizontal projected area of ​​each target primitive can be calculated first, and then the target primitives whose horizontal projected area does not exceed a preset upper limit can be regarded as the target primitives that pass the verification.

[0046] In one optional embodiment, target elements with a horizontal projected area not exceeding a preset upper limit are considered as valid target elements; for target elements with a horizontal projected area exceeding the preset upper limit, these target elements can be skipped, and logs or alarm information can be generated. This avoids generating large structural components such as walls or abnormally sized elements as solid collision proxies, thus preventing the incorrect filling of truly passable areas as occupied areas.

[0047] The preset upper limit can be greater than or equal to the horizontal projected area of ​​the largest legal obstacle unit in the 3D simulation scene, but less than the horizontal projected area of ​​the structural components in the 3D simulation scene. For example, in a warehouse simulation environment, the largest legal obstacle unit can be a double-layer shelving unit, with a horizontal projected area of ​​approximately 33.6 square meters, and the preset upper limit can be set to 40 square meters. Since the horizontal projected area of ​​structural components such as walls is usually greater than this preset upper limit, such structural components will not be mistakenly generated as solid collision proxy objects.

[0048] S4. The scanning range is defined based on the tile primitives in all primitives. The scanning range is scanned by voxels within the robot's preset passage height slice to obtain occupied grids and idle grids.

[0049] In an optional embodiment, such as Figure 2 As shown, the scanning range is defined based on tile primitives among all primitives, including: S41, select tile elements from all elements according to the preset tile naming pattern.

[0050] Specifically, the tile naming pattern can include row numbers, column numbers, tile numbers, or other fields used to represent procedural assembly units in the name. For example, in one embodiment, the tile name uses row and column numbers as suffixes, which can be used to identify the tile elements that constitute the main area of ​​the warehouse.

[0051] S42, calculate the bounding box of each tile primitive, and remove tile primitives whose bounding box side length exceeds the malformation threshold.

[0052] Specifically, the distortion threshold can be set according to the normal tile size and scene scale. For example, in one embodiment, the tile side length is approximately 4 meters, and the distortion threshold can be set to 50 meters. If a tile's bounding box side length exceeds the distortion threshold due to procedural generation anomalies, coordinate transformation anomalies, or scaling anomalies, it will be removed from the scan range calculation.

[0053] S43, take the union of the bounding boxes of the remaining tile primitives and expand them by a preset margin to obtain the scanning range.

[0054] Specifically, the preset margin can be used to accommodate wall thickness, boundary obstacles, robot safety distances, or voxel scanning errors. Since the scanning range is determined based on effective tile primitives rather than the entire scene bounding box, outliers or abnormally transformed tiles far from the main area will not significantly enlarge the map area.

[0055] After obtaining the scanning range, voxel scanning can be performed within the robot's preset passage height slice. For each grid or voxel, the presence or absence of collision geometry in the physics engine at that location can determine whether the grid is occupied or free.

[0056] In an optional embodiment, the collision geometry detected by the voxel scanning tool may include the original collision geometry of the scene, the collision geometry formed after applying collision attributes to instance roots or ordinary geometric primitives, and the aforementioned solid collision proxy bodies. For structural components such as walls, accurate mesh collision representations can be preserved; for target primitives such as shelves, racks, and ground props, continuous occupancy representations can be formed through solid collision proxy bodies. This reduces both the risk of sparse occupancy of open obstacles and the risk of approximate overfilling of uniform convex hulls.

[0057] S5 uses the centroid of all occupied grid cells as the reference point, takes the nearest free grid cell as the seed, performs a four-connected flooding to adjacent free grid cells, marks the free grid cells traversed by the flooding as free grid cells, and marks the free grid cells not traversed by the flooding as unknown grid cells, and outputs a three-value grid map.

[0058] Specifically, the centroid of an occupied grid can be calculated based on the coordinates of all occupied grids, and this centroid can be used as a reference point. Within the set of free grids, the free grid closest to this reference point can be searched, and this free grid can be used as the flooding seed. Therefore, the flooding seed is usually located inside the main scene or near the center of obstacles, reducing the probability of flooding starting from empty areas outside the scene.

[0059] Starting with the flood seed, a four-connectivity flood is performed on adjacent free grids in the four directions (up, down, left, and right) within the free grid. Free grids traversed by the flood are marked as free grids, while those not traversed are marked as unknown grids. Occupied grids remain occupied, resulting in a three-valued grid map including occupied, free, and unknown states. Therefore, only free areas connected to the flood seed and reachable by the robot are marked as free areas; empty, closed, or unreachable areas outside the scene, even if they appear free in voxel scans, are marked as unknown areas, thus preventing the path planner from misclassifying unreachable areas as passable areas.

[0060] The generated ternary raster map can include image files and parameter files. The image files represent occupied, free, and unknown raster cells with different pixel values; the parameter files record information such as map resolution, origin, occupancy threshold, and free threshold. For example, in one embodiment, the map resolution is 0.05 meters, the occupancy threshold is 0.65, and the free threshold is 0.196.

[0061] In an optional embodiment, a ternary grid map can be output to a data acquisition system. The data acquisition system can expand the occupied grids in the ternary grid map based on the map and the robot's dimensions, generating path planning grids and accessibility determination grids. Since open obstacles and ground props already occupy areas in the ternary grid map, path planning will avoid objects such as shelves, cones, and forklifts. When the robot actually enters a non-accessible area, the data acquisition system can determine a collision and trigger an automatic reset. Therefore, without changing the original path planning and reset logic of the data acquisition system, it can be made effective for ground props that were originally missing from the map.

[0062] In an optional embodiment, if it is necessary to parametrically add new obstacles to an existing scene, such as randomly placing several traffic cones, a pixel-domain writing method equivalent to generating solid collision surrogates can be used. Specifically, on an occupancy map image with the same origin and resolution as the scene, the horizontal projection coverage area of ​​the new obstacle is directly written as the occupancy area at the location of the new obstacle. This method, along with generating solid collision surrogates in a 3D scene, is an implementation method of writing the target projection coverage area into the occupancy representation in the same coordinate system.

[0063] In an optional embodiment, the occupancy grid map generation method of this application can be executed in batches on multiple procedurally generated 3D simulation scenes from random seeds, sequentially completing scene generation, occupancy grid map generation, path planning, and data acquisition, and can resume execution based on the processed scene number after an interruption. Since this application embodiment does not require deinstantiation of the source assets or manual specification of the scanning range, it is suitable for unattended batch generation of large-scale simulation data.

[0064] To more clearly illustrate the above-described method for generating occupied grid maps, in some embodiments, the method for generating occupied grid maps according to the embodiments of this application can also be described using the following mathematical form. The meanings of some related symbols are shown in Table 1.

[0065] Table 1. Symbol Explanation

[0066] For target primitive recognition, primitive Whether something is a target primitive can be represented by equation (1):

[0067] In other words, in primitives Any channel in the name, semantic tag, or reference asset path and a preset set of keywords If a match is successful, the element is identified as the target element; otherwise, the element is not identified as the target element.

[0068] For area verification, primitives Horizontal projected area Can be derived from primitives The world bounding box is determined as shown in equation (2):

[0069] in, , , , Representing primitives respectively The world bounding box has maximum and minimum coordinates in two horizontal directions.

[0070] Is it for primitives? The generation of a solid collision proxy can be represented by equation (3):

[0071] In other words, only when the primitive It is identified as a target primitive, and its horizontal projected area does not exceed the preset upper limit. Only then is a solid collision proxy generated at the world pose of the primitive.

[0072] In some embodiments, a preset upper limit is provided. Equation (4) can be satisfied:

[0073] in, This represents the horizontal projected area of ​​the largest legal obstacle unit. This represents the horizontal projected area of ​​the smallest structural component. Therefore, legal obstacle units can pass the area check, while structural components such as walls can be excluded from the solid collision proxy object generation.

[0074] For the scan range, obtain the tile primitive set according to the tile naming pattern. Then, remove bounding boxes whose maximum side length exceeds the malformation threshold. The bounding boxes of the remaining tile primitives are then horizontally projected to form a union and an outer margin. To obtain the scanning range As shown in equation (5):

[0075] in, This indicates that the area will be expanded outwards by a preset margin. .

[0076] In the scanning range Inside, and at the robot's passage height slice According to grid cell size Perform a voxel scan to obtain the initial raster state. .in, Represents a grid To occupy the grid, Represents a grid This is an empty grid.

[0077] For free space determination, occupying the centroid of the grid. and flood seeds It can be expressed by equation (6):

[0078] That is, first calculate the centroids of all cells occupying the grid. Then, select the free grid cell closest to the centroid from the free grid cells as the flood seed. .

[0079] Subsequently, with Starting from the set of free grid cells, perform four-connected flooding to obtain the free space connected domains reachable by the flooding. As shown in equation (7):

[0080] The final output is a ternary raster map: for any raster ,like If it occupies a grid, then mark it as occupying a grid; if and If so, then mark it as a free grid; if and If it is, then mark it as an unknown raster.

[0081] The above mathematical formalization corresponds to steps S1 to S5: Equation (1) corresponds to target primitive recognition, Equations (2) to (4) correspond to area verification and solid collision proxy generation conditions, Equation (5) corresponds to scanning range definition, and Equations (6) and (7) correspond to flooding seed selection and free space connected component determination. The time complexity of recognition traversal is O(P), where P is the total number of scene primitives; the time complexity of solid collision proxy generation is O(N), where N is the number of target primitives that pass verification and generate solid collision proxies. All of the above processing is scene-level one-time offline processing, without adding computational overhead to the frame-by-frame path of data acquisition or model training.

[0082] In summary, the occupied grid map generation method of this application first loads a procedurally generated 3D simulation scene, then identifies target primitives that need to be supplemented with occupied representations based on primitive names, semantic tags, and referenced asset paths, and generates solid collision proxies that participate in physical collisions but do not participate in rendering at the world pose of the target primitives, so that open obstacles and ground props can form continuous collision geometry that can be perceived by voxel scanning in the physics engine; at the same time, the voxel scanning range is automatically defined based on tile primitives, and voxel scanning is performed within the robot's preset passage height slice to obtain occupied grids and free grids; further, free grids are selected as flooding seeds with the centroid of all occupied grids as reference points, and reachable free areas are marked as free grids and unconnected free areas are marked as unknown grids through four-connectivity flooding, thereby outputting a three-valued grid map including occupied, free, and unknown states.

[0083] Therefore, the method for generating occupied grid maps according to the embodiments of this application has at least the following beneficial effects: First, solid collision proxies only participate in physical collisions and not in rendering. Therefore, without modifying the source assets, destroying the instantiation reference structure, or polluting rendering training data such as RGB images, semantic segmentation maps, and depth maps, they can supplement the collision geometry of open obstacles and ground props in voxel scanning. This allows objects such as shelves, stacks, traffic cones, and forklifts to form continuous solid occupancy in the occupied grid map, reducing the risk of paths crossing obstacles due to missed obstacle detection or sparse occupancy. Second, since the scanning range is automatically defined based on tile primitives and deformed tiles can be removed, it can avoid outliers or abnormally transformed tiles from expanding the map size and reduce the impact of empty areas outside the scene on map generation and subsequent planning calculations. Third, by using free grids near the centroid of the grid as seeds for four-connectivity flooding, only free grids connected to the reachable area of ​​the main body are marked as free grids, while unconnected free areas are marked as unknown grids. This can reduce the probability of empty areas outside the scene or closed unreachable areas being misjudged as passable areas.

[0084] Fourth, the generated ternary grid map can be used by the data acquisition system for occupancy expansion, path planning, and accessibility determination, enabling path planning and automatic collision reset to apply to ground props and open obstacles, thereby improving the automation and stability of batch acquisition of navigation training data in procedural simulation scenarios.

[0085] This application also provides an occupancy grid map generation apparatus, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the occupancy grid map generation method described in any of the foregoing embodiments.

[0086] like Figure 3 As shown, the occupancy grid map generation apparatus 500 includes a processor 501 and a memory 503. The processor 501 and the memory 503 are connected, for example, via a bus 502. Optionally, the occupancy grid map generation apparatus 500 may further include a transceiver 504. It should be noted that in practical applications, the transceiver 504 is not limited to one, and the structure of this occupancy grid map generation apparatus 500 does not constitute a limitation on the embodiments of this application.

[0087] Processor 501 may be a CPU (Central Processing Unit), a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. It can implement or execute the various exemplary logic blocks, modules, and circuits described in conjunction with the disclosure of this application. Processor 501 may also be a combination that implements computational functions, such as including one or more microprocessor combinations, a combination of a DSP and a microprocessor, etc.

[0088] Bus 502 may include a pathway for transmitting information between the aforementioned components. Bus 502 may be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus, etc. Bus 502 can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 3 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0089] The memory 503 stores a computer program corresponding to the occupancy grid map generation method of the above embodiments of this application. This computer program is controlled and executed by the processor 501. The processor 501 executes the computer program stored in the memory 503 to implement the content shown in the foregoing method embodiments.

[0090] Among them, the grid map generation device 500 includes, but is not limited to: simulation workstation, server, desktop computer, laptop, vehicle computing platform, edge computing device or other electronic device with computing capabilities. Figure 3 The illustrated grid map generation device 500 is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0091] This application also provides a computer-readable storage medium storing a computer program thereon. When the computer program is executed by a processor, it implements the occupancy grid map generation method described in any of the foregoing embodiments.

[0092] It should be noted that the logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be specifically implemented in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable media include: an electrical connection having one or more wires (electronic device), a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Alternatively, the computer-readable medium may be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in a computer memory.

[0093] It should be understood that various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0094] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0095] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0096] In this application, unless otherwise expressly specified and limited, the terms "installation," "connection," "joining," and "fixing," etc., should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral part; they can refer to a mechanical connection or an electrical connection; they can refer to a direct connection or an indirect connection through an intermediate medium; they can refer to the internal communication of two components or the interaction between two components, unless otherwise expressly limited. Those skilled in the art can understand the specific meaning of the above terms in this application according to the specific circumstances.

[0097] In this application, unless otherwise expressly specified and limited, "above" or "below" the second feature can mean that the first feature is in direct contact with the second feature, or that the first feature is in indirect contact with the second feature through an intermediate medium. Furthermore, "above," "on top of," and "over" the second feature can mean that the first feature is directly above or diagonally above the second feature, or simply that the first feature is at a higher horizontal level than the second feature. "Below," "below," and "under" the second feature can mean that the first feature is directly below or diagonally below the second feature, or simply that the first feature is at a lower horizontal level than the second feature.

[0098] Although embodiments of this application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting this application. Those skilled in the art can make changes, modifications, substitutions and variations to the above embodiments within the scope of this application.

Claims

1. A method for generating an occupied raster map, characterized in that, The method includes: Load the procedurally generated 3D simulation scene; Traverse all primitives in the 3D simulation scene, match the name, semantic tag, and reference asset path of each primitive with a preset keyword set, and determine the target primitive based on the matching results; A solid collision proxy is generated at the world pose of each target primitive to participate in physical collision but not in rendering, so as to supplement the target primitive with collision geometry that can be perceived by voxel scanning in the physics engine. The scanning range is defined based on the tile primitives in all primitives. The scanning range is then scanned using voxels within the robot's preset passage height slice to obtain occupied and idle grids. Using the centroids of all occupied grid cells as reference points, take the nearest free grid cell as a seed, perform a four-connectivity flooding to adjacent free grid cells, mark the free grid cells traversed by the flooding as free grid cells, and mark the free grid cells not traversed by the flooding as unknown grid cells, and output a three-value grid map.

2. The method for generating a grid map according to claim 1, characterized in that, The step of matching the name, semantic tag, and reference asset path of each graphic element with a preset keyword set, and determining the target graphic element based on the matching result, includes: The names, semantic tags, and referenced asset paths of the graphic elements are used as channels to match with a preset set of keywords; If any channel is successfully matched, then that element is identified as the target element.

3. The method for generating an occupied grid map according to claim 2, characterized in that, The preset keyword set is obtained in the following way: The primitives in the three-dimensional simulation scene are traversed to extract the names, semantic tags, and reference asset paths of the primitives located within the robot's travel height range, wherein the reference asset path is the model file path referenced by the primitive; Based on the distribution of extracted names, semantic tags, and referenced asset paths, keywords corresponding to preset open obstacles and / or preset ground props are determined, and the determined keywords are written into the preset keyword set.

4. The method for generating a grid map according to claim 1, characterized in that, Before generating solid collision proxies that participate in physical collisions but do not participate in rendering at the world pose of each of the target primitives, the method further includes: Calculate the horizontal projected area of ​​each of the target primitives; Target elements whose horizontal projected area does not exceed the preset upper limit are considered as valid target elements.

5. The method for generating an occupied grid map according to claim 4, characterized in that, The preset upper limit is greater than or equal to the horizontal projected area of ​​the largest legal obstacle unit in the three-dimensional simulation scene, and less than the horizontal projected area of ​​the structural component in the three-dimensional simulation scene.

6. The method for generating an occupied grid map according to claim 1, characterized in that, The step of defining the scanning range based on tile primitives among all primitives includes: Tile elements are selected from all the elements according to a preset tile naming pattern; Calculate the bounding box of each tile primitive and remove tile primitives whose bounding box side length exceeds the distortion threshold; The scanning range is obtained by taking the union of the bounding boxes of the remaining tile primitives and expanding them outward by a preset margin.

7. The method for generating an occupied grid map according to claim 1, characterized in that, The method further includes: The ternary grid map is output to the data acquisition system, so that the data acquisition system can expand the occupied grids in the ternary grid map according to the ternary grid map and the robot's external dimensions to generate path planning grids and accessibility determination grids.

8. The method for generating an occupied grid map according to any one of claims 1 to 7, characterized in that, In the three-dimensional simulation scene, at least some primitives are assembled by instantiation and reference, and the source assets of at least some primitives are not configured with physical colliders.

9. An apparatus for generating a grid map, characterized in that, The method includes a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the occupation grid map generation method according to any one of claims 1 to 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the occupancy grid map generation method according to any one of claims 1 to 8.

Images