Method for updating high-precision point cloud map of mining area scene

Abstract

The invention discloses a mining area scene high-precision point cloud map updating method. Firstly, point cloud mapping is carried out on data collected in different time periods; track alignment is carried out on the obtained point cloud data, and data mapping results collected at different times are spliced; carrying out map updating, cutting the map into blocks according to the track, and updating the point cloud of the selected area according to the area to be updated; and finally, a result after map updating is exported. According to the method, a complex calculation method used in the prior art is not needed, a point cloud replacement method is adopted, the point cloud map is updated according to the collection route, the point cloud passed by the new route is used for replacing the point cloud passed by the old route, implementation is simple, the updated point cloud accords with the actual situation, and precision is high. Meanwhile, the method does not need other sensors, and the periodic updating cost of the point cloud map is lower.

Description

Technical Field

[0001] The present invention relates to a map updating method, and in particular to a high-precision point cloud map updating method for a mining scene, and belongs to the technical field of autonomous driving. Background Art

[0002] In the research of unmanned driving technology, the development of autonomous driving technology has put forward very high requirements on the stability of positioning. Positioning is divided into combined navigation and laser positioning.

[0003] Laser positioning relies heavily on point cloud maps. The accuracy and effectiveness of point cloud maps have a great impact on laser positioning. Scene changes will cause the stability of real-time laser positioning to drop significantly. Therefore, for scenes such as mining areas where the environment changes frequently, point cloud maps need to be updated frequently to ensure positioning accuracy and stability. Existing point cloud map update solutions are generally divided into two types:

[0004] 1. Professional collection: This method relies on professional collection vehicles and personnel. The advantages of this method are high accuracy and strong adaptability, but at the same time this method is relatively expensive, requires large data storage capacity and bandwidth, and requires specially trained collection personnel. Therefore, it is not suitable for map updates in mining areas.

[0005] 2. Crowdsourcing collection: The task of map update is assigned to vehicles on the road. Vehicle-side sensors are used to detect environmental changes and compare them with high-precision maps. When the environment changes, the data is uploaded to the cloud and then sent to other vehicles to quickly update the map data. The advantages of this method are relatively low cost and good real-time performance, but the accuracy is difficult to guarantee. Summary of the invention

[0006] The technical problem to be solved by the present invention is to overcome the shortcomings of the prior art and provide a method for updating a high-precision point cloud map of a mining area scene, which can achieve real-time and rapid updating while ensuring map accuracy.

[0007] In order to achieve the above objectives, the specific technical solution of the present invention is as follows: A method for updating a high-precision point cloud map of a mining area scene comprises the following specific steps:

[0008] Step 1: construct point cloud maps for data collected in different time periods;

[0009] Step 2: align the point cloud data obtained in the previous step and stitch the mapping results of the data collected at different times;

[0010] Step 3: Update the map, slice the map according to the trajectory, and update the point cloud of the selected area according to the area to be updated;

[0011] Step 4: Finally, export the results after the map update.

[0012] Furthermore, in step 1, the time period is determined according to the collection time, the frequency of data collection is once a week, and at least 5 time periods of data are collected. At the same time, the data routes collected each time overlap, and the overlapping part is at least 1km. The collected data at least includes laser, inertial navigation, imu, camera and wheel speed data, and each data is collected by the corresponding collection equipment on the heavy truck.

[0013] Furthermore, in the step 2, the specific contents are as follows: each time the collected data is subjected to feature extraction and matching of the point cloud to obtain the odometer trajectory, each trajectory point corresponds to a frame of point cloud, each trajectory point is traversed, and other trajectory points within a radius of 45m are obtained, and the relative pose between the point clouds corresponding to the two trajectory points is obtained through GICP matching, and the relative pose between the odometer trajectories, the relative pose obtained by GICP matching, and the absolute pose constraint obtained by GPS constraint are used to construct an optimization problem, and the optimized pose of each trajectory point is obtained through CERES solution to achieve trajectory alignment, and the point clouds of different trajectories are transformed to the world coordinate system through the above-mentioned optimized pose, and the point clouds can be directly spliced.

[0014] Furthermore, in step 3, the specific steps are as follows:

[0015] Step 3.1, determine the minimum and maximum values ​​of the trajectory coordinates according to the collected trajectory, which are recorded as min_pt and max_pt respectively;

[0016] Step 3.2, select the specified resolution, calculate the minimum and maximum values ​​of the grid index, counted as min_x, min_y, max_x, max_y, calculate the number of grids in the x direction and the number of grids in the y direction grid_x and grid_y;

[0017] Step 3.3, calculate the grid id according to the trajectory pose, and save the corresponding relationship between the grid id and the pose;

[0018] Step 3.4, calculate the index of each point in the grid in each frame point cloud, and divide the point cloud with grid index in the corresponding range into the specified grid, as follows: from a point cloud filter_cloud that has been transformed to the world coordinate system after the previous steps, filter out the points located in a specific grid grid, and add these points to the final divided grid point cloud grid_cloud, each point is represented by pt; where the size of the grid is defined by kGridSize, and the index of the grid is represented by cell_x and cell_y: cell_x represents the grid index in the x direction, and cell_y represents the grid index in the y direction; min_x and min_y are the minimum values ​​of the grid index in the x direction and the grid index in the y direction of the point cloud in the world coordinate system, which are used to calculate the offset of the point pt relative to the lower left corner of the grid;

[0019] First, calculate the offset tmp_x of point pt in the x direction relative to the lower left corner of the grid: pt.x-cell_x*kGridSize-min_x;

[0020] Among them, pt.x is the coordinate value of the point cloud in the x direction in the world coordinate system, and cell_x*kGridSize represents the starting position of the current grid in the x direction;

[0021] Calculate the offset tmp_y of point pt in the y direction relative to the lower left corner of the grid: pt.y-cell_y*kGridSize-min_y; where pt.y is the coordinate value of the point cloud in the y direction in the world coordinate system, and cell_y*kGridSize represents the starting position of the current grid in the y direction;

[0022] Check whether tmp_x and tmp_y are both in the range of 0 to kGridSize. If any of the two values ​​is not in this range, it means that the point pt is not in the current grid, so skip this point and continue to check the next point.

[0023] If tmp_x and tmp_y are both in the range of 0 to kGridSize, then the point pt is in the current grid, then the point is divided into the grid and added to the grid_cloud point cloud;

[0024] Step 3.5, according to the point cloud in the specified grid updated in the previous step, export the updated point cloud result.

[0025] Furthermore, in step 3.2, the resolution is the size of the cutting grid, which is calculated as follows:

[0026] int kMargin = 2 * kGridSize;

[0027] int min_x=kGridSize*(int(min_pt.x()) / kGridSize)-kMargin;

[0028] int min_y=kGridSize*(int(min_pt.y()) / kGridSize)-kMargin;

[0029] int max_x=kGridSize*((int(max_pt.x())+kGridSize) / kGridSize)+kMargin;

[0030] int max_y=kGridSize*((int(max_pt.y())+kGridSize) / kGridSize)+kMargin;

[0031] int grid_x=(max_x-min_x) / kGridSize;

[0032] int grid_y=(max_y-min_y) / kGridSize;

[0033] * represents multiplication, / represents division, + represents addition, and - represents subtraction.

[0034] Where int represents an integer, kGridSize represents the grid size, and kMargin is twice the grid size.

[0035] min_x is the minimum value of the grid index in the x direction, min_y is the minimum value of the grid index in the y direction,

[0036] max_x is the maximum value of the grid index in the x direction, and max_y is the maximum value of the grid index in the y direction.

[0037] min_pt.x() is the minimum value of the trajectory coordinate in the x direction, and min_pt.y() is the minimum value of the trajectory coordinate in the y direction.

[0038] max_pt.x() is the maximum value of the trajectory coordinate in the x direction, and max_pt.y() is the maximum value of the trajectory coordinate in the y direction.

[0039] int(min_pt.x()) means rounding min_pt.x(), int(min_pt.y()) means rounding min_pt.y()

[0040] int(max_pt.x()) means rounding max_pt.x(), int(max_pt.y()) means rounding max_pt.y()

[0041] grid_x represents the number of grids in the x direction, and grid_y represents the number of grids in the y direction.

[0042] Furthermore, in step 3.3, the specific calculation method is as follows:

[0043] int cell_x=(pose[0]+r*kLaserLen) / kGridSize-min_x / kGridSize;

[0044] int cell_y=(pose[1]+c*kLaserLen) / kGridSize-min_y / kGridSize;

[0045] int64_t cell_id=cell_x+grid_x*cell_y;

[0046] Among them, cell_x represents the grid index in the x direction, cell_y represents the grid index in the y direction, cell_id represents the grid id, pose[0] represents the coordinate value of the trajectory pose in the x direction, and pose[0] represents the coordinate value of the trajectory pose in the y direction;

[0047] The values ​​of r are -1, 0, 1, the values ​​of c are -1, 0, 1, kLaserLen represents the radius of the radar point cloud, kGridSize is the grid size, min_x and min_y are the minimum value of the grid index in the x direction and the minimum value of the grid index in the y direction calculated in step 3.2, int64_t represents a 64-bit integer. Through this calculation method, the cell_id corresponding to each pose can be obtained.

[0048] Compared with the prior art, the beneficial effects of the present invention are:

[0049] 1. The present invention does not need to adopt the complex calculation method used in the prior art. The point cloud map is updated according to the acquisition route through the point cloud replacement method, and the point cloud passed by the old route is replaced by the point cloud passed by the new route. The implementation is relatively simple, and the updated point cloud is more consistent with the actual situation and has high accuracy.

[0050] 2. This solution does not require the use of other sensors, and the cost of periodic updates of point cloud maps is lower. BRIEF DESCRIPTION OF THE DRAWINGS

[0051] Figure 1 Flowchart of the invention.

[0052] Figure 2 It is a schematic diagram of the trajectory in the invention.

[0053] Figure 3 for Figure 2 Schematic diagram of the trajectory of route_2 in .

[0054] Figure 4 Schematic diagram of the point cloud before updating in the present invention.

[0055] Figure 5 Schematic diagram of the updated point cloud in the present invention. DETAILED DESCRIPTION

[0056] The technical solution of the present invention is further described in detail below in conjunction with the accompanying drawings:

[0057] This embodiment proposes a method for updating a high-precision point cloud map of a mining area scene. The process is as follows: Figure 1 As shown, the following steps are included:

[0058] Step 1: construct point cloud maps for data collected in different time periods. In this embodiment, the time period is determined according to the collection time. Data is collected once a week, and at least 5 time periods are collected each time. The data routes collected each time need to overlap, and the overlapping part is at least 1km. The collected data includes laser, inertial navigation, imu, camera and wheel speed data, and each data is collected separately by the collection equipment on the heavy truck.

[0059] Step 2: Align the point cloud data obtained in the previous steps and splice the mapping results of the data collected at different times; extract and match the features of the point cloud for each collected data to obtain the odometer trajectory. Each trajectory point corresponds to a frame of point cloud. Traverse each trajectory point to obtain other trajectory points within a radius of 45m. Use GICP matching to obtain the relative pose between the point clouds corresponding to the two trajectory points. Use the relative pose between the odometer trajectories, the relative pose obtained by GICP matching, and the absolute pose constraint obtained by GPS constraints to construct an optimization problem. Use Ceres to solve the optimized pose of each trajectory point to achieve trajectory alignment. Transform the point clouds of different trajectories to the world coordinate system through the above optimized poses, and then directly splice the point clouds.

[0060] Step 3: Update the map, slice the map according to the trajectory, and update the point cloud of the selected area according to the area to be updated;

[0061] Step 3.1, determine the minimum and maximum values ​​of the trajectory coordinates according to the collected trajectory, which are recorded as min_pt and max_pt;

[0062] Step 3.2, select the specified resolution, calculate the minimum and maximum values ​​of the grid index, counted as min_x, min_y, max_x, max_y, calculate the number of grids in the x direction and the number of grids in the y direction grid_x and grid_y;

[0063] The resolution refers to the size of the grid. If the grid is too small, too many grids need to be stored. If the grid is too large, the point cloud cannot be saved. Therefore, in this embodiment, 200m×200m is selected. The calculation method is as follows:

[0064] int kMargin = 2 * kGridSize;

[0065] int min_x=kGridSize*(int(min_pt.x()) / kGridSize)-kMargin;

[0066] int min_y=kGridSize*(int(min_pt.y()) / kGridSize)-kMargin;

[0067] int max_x=kGridSize*((int(max_pt.x())+kGridSize) / kGridSize)+kMargin;

[0068] int max_y=kGridSize*((int(max_pt.y())+kGridSize) / kGridSize)+kMargin;

[0069] int grid_x=(max_x-min_x) / kGridSize;

[0070] int grid_y=(max_y-min_y) / kGridSize;

[0071] * represents multiplication, / represents division, + represents addition, and - represents subtraction.

[0072] Where int represents an integer, kGridSize represents the grid size, which is 200 here, and kMargin is twice the grid size.

[0073] min_x is the minimum value of the grid index in the x direction, min_y is the minimum value of the grid index in the y direction,

[0074] max_x is the maximum value of the grid index in the x direction, and max_y is the maximum value of the grid index in the y direction.

[0075] min_pt.x() is the minimum value of the trajectory coordinate in the x direction, and min_pt.y() is the minimum value of the trajectory coordinate in the y direction.

[0076] max_pt.x() is the maximum value of the trajectory coordinate in the x direction, and max_pt.y() is the maximum value of the trajectory coordinate in the y direction.

[0077] int(min_pt.x()) means rounding min_pt.x(), int(min_pt.y()) means rounding min_pt.y()

[0078] int(max_pt.x()) means rounding max_pt.x(), int(max_pt.y()) means rounding max_pt.y()

[0079] grid_x represents the number of grids in the x direction, grid_y represents the number of grids in the y direction

[0080] Step 3.3, calculate the grid id according to the trajectory pose and save the correspondence between the grid id and pose. The calculation method is as follows

[0081] int cell_x=(pose[0]+r*kLaserLen) / kGridSize-min_x / kGridSize;

[0082] int cell_y=(pose[1]+c*kLaserLen) / kGridSize-min_y / kGridSize;

[0083] int64_t cell_id=cell_x+grid_x*cell_y;

[0084] cell_x represents the grid index in the x direction, cell_y represents the grid index in the y direction, and cell_id represents the grid id.

[0085] pose[0] represents the coordinate value of trajectory pose in the x direction, and pose[0] represents the coordinate value of trajectory pose in the y direction;

[0086] The values ​​of r are -1, 0, 1, the values ​​of c are -1, 0, 1, kLaserLen represents the radius of the radar point cloud, which is 100m here, kGridSize represents the grid size, which is 200m here, min_x and min_y represent the minimum value of the grid index in the x direction and the minimum value of the grid index in the y direction calculated in the previous step, int64_t represents a 64-bit integer. Through this calculation method, the cell_id corresponding to each pose can be obtained.

[0087] Step 3.4, calculate the index of each point in the grid in each frame of the point cloud, and divide the point cloud with the grid index in the corresponding range into the specified grid.

[0088] for(auto&pt:*filter_cloud){

[0089] double tmp_x=pt.x-cell_x*kGridSize-min_x;

[0090] double tmp_y=pt.y-cell_y*kGridSize-min_y;

[0091] if(tmp_x<0||tmp_x>kGridSize)

[0092] continue;

[0093] if(tmp_y<0||tmp_y>kGridSize)

[0094] continue;

[0095] grid_cloud.push_back(pt);

[0096] }

[0097] filter_cloud is the point cloud transformed to the world coordinate system through the above steps, traversing the point cloud

[0098] pt.x is the coordinate value of the point cloud in the x direction in the world coordinate system.

[0099] pt.y is the coordinate value of the point cloud in the y direction in the world coordinate system.

[0100] cell_x represents the grid index in the x direction, cell_y represents the grid index in the y direction, which is calculated by step 3.3 and is the grid size, which is 200m here. min_x and min_y are the minimum values ​​of the grid index in the x direction and the minimum value of the grid index in the y direction calculated in the previous step. tmp_x is the difference between the grid index value in the x direction calculated by the above formula and the minimum grid index value in the x direction. tmp_y is the difference between the grid index value in the y direction calculated by the above formula and the minimum grid index value in the y direction. Determine whether tmp_x and tmp_y are in the range of 0 to kGridSize. If not, skip it. If so, divide this point into this grid. grid_cloud represents the final divided grid point cloud.

[0101] Step 3.5, update the point cloud in the specified grid and export the updated point cloud result.

[0102] Step 4: Finally, export the results after the map update.

[0103] Among them, Figure 2 As shown in the figure, route_1, route_2, and route_3 represent the trajectories at different times, and block_1 to block_12 represent the results of cutting the point cloud into blocks. When there are multiple routes passing through a block, take route_2 as an example. Figure 3 As shown in the figure, route_2 represents the latest track, and route_2 passes through four blocks, block_5, block_6, block_7, and block_8. When the map needs to be updated, only the point cloud at the latest time is retained for the places where the latest route passes, as shown in the shaded area above. For places where no new route passes, the point cloud of the corresponding block is filled with the old route. This can basically ensure that the updated point cloud map is consistent with the actual environment.

[0104] For each trajectory point in route_2, search for trajectory points of other routes within a radius of 5m for each trajectory point, and delete the point clouds corresponding to the trajectory points of other routes within a radius of 5m. For example, in block_6, take each trajectory point of route_2 as the origin and 5m as the radius, compare the distance between each trajectory point in route_1 and route_3 and the origin of route_2. For the point clouds within a radius of 5m, delete the point clouds corresponding to route_1 and route_3, and only keep the point cloud of route_2, then the map is updated.

[0105] like Figure 4 As shown, it represents the point cloud before updating, corresponding to Figure 2 In block_2, the point cloud, Figure 5 It represents the updated point cloud. At the same location, the ore pile changes before and after the point cloud update, realizing the map update.

[0106] The above shows and describes the basic principles, main features and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above specific embodiments. The above specific embodiments and the description in the specification are only for further illustrating the principles of the present invention. Without departing from the spirit and scope of the present invention, the present invention may have various changes and improvements, which fall within the scope of the present invention to be protected. The scope of the present invention to be protected is defined by the claims and their equivalents.

Claims

1. A method for updating a high-precision point cloud map of a mining area scene, characterized by: The specific steps include: Step 1: construct point cloud maps for data collected in different time periods; Step 2: align the point cloud data obtained in the previous step and stitch the mapping results of the data collected at different times; Step 3: Update the map, slice the map according to the trajectory, and update the point cloud of the selected area according to the area to be updated; Step 4: Finally, export the results after the map update.

2. The method for updating a high-precision point cloud map of a mining area scene according to claim 1 is characterized in that: In step 1, the time period is determined according to the collection time, the frequency of data collection is once a week, and data of at least 5 time periods are collected.

3. The method for updating a high-precision point cloud map of a mining area scene according to claim 2 is characterized in that: In step 1, the data routes collected each time have overlaps, and the overlapped portion is at least 1 km.

4. The method for updating a high-precision point cloud map of a mining area scene according to claim 1, characterized in that: In step 1, the collected data includes at least laser, inertial navigation, imu, camera and wheel speed data, and each data is collected by the corresponding collection equipment on the heavy truck.

5. The method for updating a high-precision point cloud map of a mining area scene according to claim 1, characterized in that: In the step 2, the specific contents are as follows: each time the collected data is subjected to feature extraction and matching of point clouds to obtain the odometer trajectory, each trajectory point corresponds to a frame of point cloud, each trajectory point is traversed, and other trajectory points within a radius of 45m are obtained. The relative pose between the point clouds corresponding to the two trajectory points is obtained through GICP matching, and the relative pose between the odometer trajectories, the relative pose obtained by GICP matching, and the absolute pose constraint obtained by GPS constraint are used to construct an optimization problem. The optimized pose of each trajectory point is obtained through CERES solution to achieve trajectory alignment. The point clouds of different trajectories are transformed to the world coordinate system through the above-mentioned optimized pose, and the point clouds can be directly spliced.

6. The method for updating a high-precision point cloud map of a mining area scene according to claim 1, characterized in that: In step 3, the specific steps are as follows: Step 3.1, determine the minimum and maximum values ​​of the trajectory coordinates according to the collected trajectory, which are recorded as min_pt and max_pt respectively; Step 3.2, select the specified resolution, calculate the minimum and maximum values ​​of the grid index, counted as min_x, min_y, max_x, max_y, calculate the number of grids in the x direction and the number of grids in the y direction grid_x and grid_y; Step 3.3, calculate the grid id according to the trajectory pose, and save the corresponding relationship between the grid id and the pose; Step 3.4, calculate the index of each point in each frame of the point cloud in the grid, and divide the point cloud with the grid index in the corresponding range into the specified grid, as follows: From a point cloud filter_cloud that has been transformed to the world coordinate system through the previous steps, filter out the points located in a specific grid grid, and add these points to the final divided grid point cloud grid_cloud, each point is represented by pt; where the size of the grid is defined by kGridSize, and the index of the grid is represented by cell_x and cell_y: cell_x represents the grid index in the x direction, and cell_y represents the grid index in the y direction; min_x and min_y are the minimum values ​​of the grid index in the x direction and the grid index in the y direction of the point cloud in the world coordinate system, which are used to calculate the offset of the point pt relative to the lower left corner of the grid; First, calculate the offset tmp_x of point pt in the x direction relative to the lower left corner of the grid: pt.x-cell_x*kGridSize-min_x; Among them, pt.x is the coordinate value of the point cloud in the x direction in the world coordinate system, and cell_x*kGridSize represents the starting position of the current grid in the x direction; Calculate the offset tmp_y of point pt in the y direction relative to the lower left corner of the grid: pt.y-cell_y*kGridSize-min_y; where pt.y is the coordinate value of the point cloud in the y direction in the world coordinate system, and cell_y*kGridSize represents the starting position of the current grid in the y direction; Check whether tmp_x and tmp_y are both in the range of 0 to kGridSize. If any of the two values ​​is not in this range, it means that the point pt is not in the current grid, so skip this point and continue to check the next point. If tmp_x and tmp_y are both in the range of 0 to kGridSize, then the point pt is in the current grid, then the point is divided into the grid and added to the grid_cloud point cloud; Step 3.5, according to the point cloud in the specified grid updated in the previous step, export the updated point cloud result.

7. The method for updating a high-precision point cloud map of a mining area scene according to claim 1, characterized in that: In step 3.2, the resolution is the size of the cutting grid, which is calculated as follows: int kMargin = 2 * kGridSize; int min_x=kGridSize*(int(min_pt.x()) / kGridSize)-kMargin; int min_y=kGridSize*(int(min_pt.y()) / kGridSize)-kMargin; int max_x=kGridSize*((int(max_pt.x())+kGridSize) / kGridSize)+kMargin; int max_y=kGridSize*((int(max_pt.y())+kGridSize) / kGridSize)+kMargin; int grid_x=(max_x-min_x) / kGridSize; int grid_y=(max_y-min_y) / kGridSize; * represents multiplication, / represents division, + represents addition, and - represents subtraction. Where int represents an integer, kGridSize represents the grid size, and kMargin is twice the grid size. min_x is the minimum value of the grid index in the x direction, min_y is the minimum value of the grid index in the y direction, max_x is the maximum value of the grid index in the x direction, and max_y is the maximum value of the grid index in the y direction. min_pt.x() is the minimum value of the trajectory coordinate in the x direction, and min_pt.y() is the minimum value of the trajectory coordinate in the y direction. max_pt.x() is the maximum value of the trajectory coordinate in the x direction, and max_pt.y() is the maximum value of the trajectory coordinate in the y direction. int(min_pt.x()) means rounding min_pt.x(), int(min_pt.y()) means rounding min_pt.y() int(max_pt.x()) means rounding max_pt.x(), int(max_pt.y()) means rounding max_pt.y() grid_x represents the number of grids in the x direction, and grid_y represents the number of grids in the y direction.

8. The method for updating a high-precision point cloud map of a mining area scene according to claim 1, characterized in that: In step 3.3, the specific calculation method is as follows: int cell_x=(pose[0]+r*kLaserLen) / kGridSize-min_x / kGridSize; int cell_y=(pose[1]+c*kLaserLen) / kGridSize-min_y / kGridSize; int64_t cell_id=cell_x+grid_x*cell_y; Among them, cell_x represents the grid index in the x direction, cell_y represents the grid index in the y direction, and cell_id represents the grid id. pose[0] represents the coordinate value of trajectory pose in the x direction, and pose[0] represents the coordinate value of trajectory pose in the y direction; The values ​​of r are -1, 0, 1, the values ​​of c are -1, 0, 1, kLaserLen represents the radius of the radar point cloud, kGridSize is the grid size, min_x and min_y are the minimum value of the grid index in the x direction and the minimum value of the grid index in the y direction calculated in step 3.2, int64_t represents a 64-bit integer. Through this calculation method, the cell_id corresponding to each pose can be obtained.

Images