Engine hood side reference line checking method, device, equipment and medium

Abstract

This invention discloses a method, apparatus, equipment, and medium for verifying the side baseline of an engine hood. The verification method includes: selecting a pedestrian protection simulation model and a head shape point file, the head shape point file including multiple head shape point information; selecting a verification shell unit for the verification area; verifying the side baseline of the engine hood and displaying the verification results; in the product development cycle, pedestrian protection performance development is carried out in advance, with more rounds of optimization to find the optimal solution; quickly identifying risk points in pedestrian protection head shape tests, and optimizing the points through shape optimization to improve the pedestrian protection score rate; achieving accurate verification of the side baseline of the engine hood with 100% accuracy; and achieving rapid verification of the side baseline of the engine hood, greatly improving verification efficiency.

Description

Technical Field

[0001] This invention relates to the field of vehicle simulation technology, and in particular to a method, apparatus, equipment and medium for verifying the baseline of the engine hood side. Background Technology

[0002] Currently, pedestrian protection performance development is carried out during the product development engineering stage, that is, after the conditions for pedestrian protection analysis are met, detailed pedestrian protection CAE simulation analysis and optimization are conducted. However, with the current product development cycle of car companies shortening to 24 months or even less, the conventional approach of conducting detailed pedestrian protection analysis and optimization during the engineering stage has greatly increased the risk of achieving pedestrian protection performance development goals. There is an urgent need for a method to carry out pedestrian protection performance development at the concept stage. Summary of the Invention

[0003] The purpose of this invention is to provide a method, apparatus, device, and medium for verifying the baseline of the engine hood side, so as to solve the problems mentioned in the background art.

[0004] To achieve the above objectives, the present invention provides the following technical solution: a method for verifying the baseline of the side of an engine hood, comprising:

[0005] Select a pedestrian protection simulation model;

[0006] Select a head shape point file, which includes multiple head shape point information, wherein the head shape point information includes three-dimensional spatial coordinate information;

[0007] Select the verification shell unit for the verification area;

[0008] The calibration of the baseline on the side of the engine hood includes: determining whether the projection of the head shape point in the Z-axis direction falls within the Z-direction projection of the calibration shell unit; if it falls within the Z-direction projection of the calibration shell unit, then the head shape point is the head shape point to be measured; establishing a simulation model that stores the calibration ruler; and calculating the distance between the head shape point to be measured and the calibration ruler.

[0009] Display the verification results.

[0010] Furthermore, after selecting the head shape location file, the following are also included:

[0011] Create a head shape array. Identify all head shape points in the head shape point file and put them into the head shape array. All elements in the head shape array are objects, and each object has the following attributes: head shape point name, head shape point x coordinate, head shape point y coordinate, and head shape point z coordinate.

[0012] Furthermore, the verification shell unit for selecting the verification region also includes:

[0013] A verification area is set up, wherein the verification area is the engine hood and fenders.

[0014] Establish a set of verification shell elements and put the verification shell elements of the verification region into the set of verification shell elements.

[0015] Furthermore, determining whether the Z-axis projection of the head shape point falls within the Z-axis projection of the verification shell element also includes:

[0016] The maximum value of the verification shell unit in the positive X-axis direction is set as x_max, the minimum value in the negative X-axis direction is set as x_min, the maximum value in the positive Y-axis direction is set as y_max, and the minimum value in the negative X-axis direction is set as y_min.

[0017] Let the coordinates of the head shape point be (x, y, z). When x_min≤x≤x_max and y_min≤y≤y_max, the projection of the head shape point along the Z-axis falls within the Z-axis projection of the verification shell element.

[0018] Furthermore, establishing a simulation model for storing and verifying the ruler also includes:

[0019] Establish a model for storing and verifying the ruler;

[0020] Establish an array to store the shell elements that intersect with the longitudinal section passing through the head-shaped point;

[0021] Establish the Z-axis projection line of the storage and verification ruler at the head shape point;

[0022] Establish a temporary calibration ruler for the head-shaped points.

[0023] Furthermore, calculating the distance between the head shape measurement point and the calibration ruler also includes:

[0024] Calculate the distance between the Z-axis projection line of the calibration ruler at the head shape point and the temporary calibration ruler;

[0025] Establish a ruler for verifying the head shape points;

[0026] The distance between the head shape measurement point and the calibration ruler is calculated using Heron's formula. According to Heron's formula, the area *s* of the triangle formed by the head shape measurement point, n11, and n22 can be calculated. The Heron's formula is as follows: ; ;

[0027] in, The length of the triangle is half its perimeter, i.e. ( + + ) / 2; To check the length of the ruler; The distance between the head shape point to be measured and the endpoint n11 of the calibration ruler; The distance between the head shape point to be measured and the endpoint n22 of the calibration ruler; This is the distance between the head shape point to be tested and the calibration ruler.

[0028] Furthermore, the verification results also include:

[0029] Label the head shape location names;

[0030] The Z-axis direction of the marked portrait points is used to check the distance;

[0031] The Y-axis direction of the marked head shape points is used for verification distance;

[0032] Draw the verification results.

[0033] On the other hand, an engine hood side baseline verification device is provided, comprising:

[0034] The acquisition module is used to acquire a pedestrian protection simulation model and a head shape location file. The pedestrian protection simulation model includes a verification shell unit for the verification area, and the head shape location file includes multiple head shape location information.

[0035] The verification module is used to determine whether the projection of the head shape point in the Z-axis direction falls within the projection of the verification shell unit in the Z-direction. If it falls within the projection of the verification shell unit in the Z-direction, the head shape point is the head shape point to be tested, and a simulation model for storing the verification ruler is established.

[0036] The calculation module is used to calculate the distance between the head shape point to be measured and the calibration ruler;

[0037] The output module displays the verification results.

[0038] In another aspect, an electronic device is provided, the electronic device comprising:

[0039] One or more processors;

[0040] Storage device for storing one or more programs.

[0041] When the one or more programs are executed by the one or more processors, the one or more processors implement a method for verifying the side baseline of an engine hood as described above.

[0042] In another aspect, a computer-readable storage medium is provided, on which a computer program is stored, characterized in that, when executed by a processor, the program implements a method for verifying the side baseline of an engine hood as described above.

[0043] Compared with existing technologies, the beneficial effects of this invention are: pedestrian protection performance development is carried out in advance during the product development cycle, more rounds of optimization are conducted, and the optimal solution is found; pedestrian protection head shape test risk points are quickly identified, and point optimization is achieved through shape optimization to improve the pedestrian protection score rate; the accurate verification of the engine hood side baseline is achieved with 100% accuracy; and the rapid verification of the engine hood side baseline is achieved, greatly improving the verification efficiency. Attached Figure Description

[0044] Figure 1 This is a flowchart of a method for verifying the baseline of the engine hood side in an embodiment of the present invention;

[0045] Figure 2 This is a connection block diagram of an engine hood side baseline verification device according to an embodiment of the present invention;

[0046] Figure 3 This is a flowchart illustrating the method for verifying the baseline of the engine hood side in an embodiment of the present invention.

[0047] Figure 4 This is a schematic diagram of the automated script interface in an embodiment of the present invention;

[0048] Figure 5 This is a schematic diagram of the head shape coordinate file format in an embodiment of the present invention;

[0049] Figure 6 This is a schematic diagram illustrating the principle of calculating the distance between cur_point and ruleer in an embodiment of the present invention;

[0050] Figure 7 This is a schematic diagram of the verification results in an embodiment of the present invention;

[0051] Figure 8 This is a schematic diagram showing the structural connection of an electronic device and a computer-readable storage medium in an embodiment of the present invention;

[0052] In the diagram: 10. Memory; 11. Processor; 12. Communication bus; 13. Communication interface; 14. Computer program; 15. Storage medium; 16. Acquisition module; 17. Verification module; 18. Calculation module; 19. Output module. Detailed Implementation

[0053] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0054] In the description of this invention, unless otherwise stated, "a plurality of" means two or more; the terms "upper," "lower," "left," "right," "inner," "outer," "front end," "rear end," "head," "tail," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings, and are only for the convenience of describing the invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation of the invention. Furthermore, the terms "first," "second," "third," etc., are used for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0055] In the description of this invention, it should be noted that, unless otherwise explicitly specified and limited, the terms "connected" and "linked" should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; 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. Those skilled in the art can understand the specific meaning of the above terms in this invention based on the specific circumstances.

[0056] Please refer to the accompanying drawings in the specification. This invention provides a technical solution: such as... Figure 1 As shown, a method for verifying the baseline of the engine hood side includes the following steps:

[0057] S102. Select a pedestrian protection simulation model;

[0058] Specifically, the pedestrian protection simulation model is a component simulation model used to detect the impact of vehicles on pedestrian protection performance, which includes the three-dimensional spatial data information of the components.

[0059] S104. Select a head shape point file, wherein the head shape point file includes multiple head shape point information, and the head shape point information includes three-dimensional spatial coordinate information;

[0060] Specifically, head impact points refer to the simulated collision positions and angles of a child's or adult's head with a vehicle's hood or other components during pedestrian protection testing. Different head impact points have different mass, velocity, and collision angle requirements, and head impact points are one of the important indicators for evaluating a vehicle's pedestrian protection performance. A head impact point file is a file containing information on multiple head impact points, which are used to simulate the positions that a pedestrian's head may come into contact with during a collision. The head impact point information includes the X, Y, and Z coordinates of the pedestrian's head and the hard impact component in the same coordinate system.

[0061] S106. Select the verification shell unit of the verification area;

[0062] Specifically, according to the C-NCAP Management Rules (2021 Edition) pedestrian protection test method, when marking the baseline on the side of the engine hood, the ruler should be in contact with the engine hood or fender; therefore, the pedestrian protection simulation model selected for this step only includes the engine hood and fender.

[0063] S108. Verify the baseline of the engine hood side, including: determining whether the projection of the head shape point in the Z-axis direction falls within the verification shell unit. If it falls within the head shape point of the verification shell unit, then the head shape point is the head shape point to be measured; establish a simulation model that stores the verification ruler; calculate the distance between the head shape point to be measured and the verification ruler.

[0064] Specifically, this step includes identifying head shape points in the verification area, modeling the head shape point verification ruler, and calculating the distance between the head shape points and the verification ruler. It quickly identifies risk points in the pedestrian protection head shape test, optimizes the points through shape optimization, and improves the pedestrian protection score rate; it achieves accurate verification of the engine hood side baseline with 100% accuracy; and it achieves rapid verification of the engine hood side baseline.

[0065] S110, Display the verification results.

[0066] Specifically, by displaying the verification results, the position of the head point of the engine hood side baseline and the position of the head point verification ruler, as well as the distance between the head point and the verification ruler, are marked, thereby providing technical support for the subsequent improvement of the engine hood side baseline layout.

[0067] In the above embodiments, preferably, the present invention uses PRIMER software as an example for three-dimensional spatial data verification. It can also be implemented using programming languages ​​in other simulation / design software, such as using Tcl / Tk in Hypermesh software, Python in ANSA software, or VBScript in CATIA software. During the product development cycle, pedestrian protection performance is developed in advance, with more rounds of optimization to find the optimal solution. Risk points in pedestrian protection head shape tests are quickly identified, and point optimization is achieved through shape optimization, improving the pedestrian protection score rate. Accurate verification of the engine hood side baseline is achieved with 100% accuracy. Compared with traditional methods, the efficiency of rapid verification of the engine hood side baseline is improved by more than 99%.

[0068] Optionally, after selecting the head shape location file, the following are also included:

[0069] Create a head shape array. Identify all head shape points in the head shape point file and put them into the head shape array. All elements in the head shape array are objects, and each object has the following attributes: head shape point name, head shape point x coordinate, head shape point y coordinate, and head shape point z coordinate.

[0070] In the above embodiment, a head shape point array points_all is established, all head shape points in the head shape point file are identified and put into the array points_all, where the head shape points in the array points_all are denoted as cur_point. The PRIMER software is automated by using JavaScript for secondary development.

[0071] Optionally, the verification shell element for selecting the verification area also includes:

[0072] A verification area is set up, wherein the verification area is the engine hood and fenders.

[0073] Establish a set of verification shell elements and put the verification shell elements of the verification region into the set of verification shell elements.

[0074] In the above embodiment, a set of verification shell cells, `set_shell`, is established, and shell cells in the verification region are selected; the shell cells in the verification region are then added to the set `set_shell`. This step is automated using JavaScript in the PRIMER software through secondary development.

[0075] Optionally, determining whether the projection of the head shape point along the Z-axis falls within the head shape point of the verification shell element further includes:

[0076] The maximum value of the verification shell unit in the positive X-axis direction is set as x_max, the minimum value in the negative X-axis direction is set as x_min, the maximum value in the positive Y-axis direction is set as y_max, and the minimum value in the negative X-axis direction is set as y_min.

[0077] Let the coordinates of the head-shaped point be (x, y, z). When x_min≤x≤x_max and y_min≤y≤y_max, the projection of the head-shaped point along the Z-axis falls within the head-shaped point of the verification shell element.

[0078] In the above embodiment, an array `points_on_shells` is created to store the head shape points in the verification area. The first head shape point is retrieved from `points_all` and denoted as `cur_point`. It is determined whether the z-direction projection of `cur_point` falls within the z-direction head shape of `set_shell`; if the z-direction projection of `cur_point` falls within the z-direction head shape of `set_shell`, then `cur_point` is added to `points_on_shells`; otherwise, it is added to `points_on_shells`.

[0079] Assuming that in the verification shell element, the variables x_min are assigned a value of 9999 (which can be understood as positive infinity), x_max is assigned a value of -9999 (which can be understood as negative infinity), y_min is assigned a value of 9999 (which can be understood as positive infinity), and y_max is assigned a value of -9999 (which can be understood as negative infinity), the positive X-axis coordinate of the verification shell element is compared with x_min. If it is less than x_min, the variable x_min is updated to the X-axis coordinate of the verification shell element; if it is greater than x_max, the variable x_max is updated to the X-axis coordinate of the verification shell element; if it is less than y_min, the variable y_min is updated to the Y-axis coordinate of the verification shell element; if it is greater than y_max, the variable y_max is updated to the Y-axis coordinate of the verification shell element, thus determining the verification region.

[0080] Optionally, establishing a simulation model for storing and verifying the ruler also includes:

[0081] Establish a model for storing and verifying the ruler;

[0082] Specifically, a calibration ruler rule is created for the head shape point cur_point, and a new simulation model m_ruler is created to store the calibration ruler rule.

[0083] Establish an array to store the shell elements that intersect with the longitudinal section passing through the head-shaped point;

[0084] Specifically, an array denoted as shell_box is created to store the shell elements that intersect with the longitudinal sections of the head-shaped points. All shell elements of the pedestrian protection simulation model are obtained and placed into the array shell_cas. The array shell_cas, composed of all shell elements of the pedestrian protection simulation model, is traversed. Any shell element in shell_cas can be denoted as shell_cas[k]. The minimum x-coordinate x_min, maximum x-coordinate x_max, and minimum y-coordinate y_min of shell_cas[k] are obtained. If x_min≤points_on_shells[i].x and x_max≥points_on_shells[i].x and y_min≤0, then the shell element shell_cas[k] is placed into the array shell_box.

[0085] Establish the Z-axis projection line of the storage and verification ruler at the head shape point;

[0086] Specifically, an empty part is created to store the z-axis projection line of the calibration ruler at the head-shaped point, denoted as part_line. In the pedestrian protection simulation model, a CrossSection passing through the longitudinal section of the collision point is created, denoted as cs. All shell elements of shell_box are traversed; any shell element of shell_box can be denoted as shell_box[j]. The intersection information between cs and shell_box[j] is calculated and placed into the array data, which has 6 elements: the x-coordinate, y-coordinate, and z-coordinate of the first intersection point; the x-coordinate, y-coordinate, and z-coordinate of the second intersection point; and the z-coordinate of the second intersection point. The first intersection point n1 and the second intersection point n2 are created, and beams with endpoints n1 and n2 are created and placed into part_line.

[0087] Establish a temporary calibration ruler for the head-shaped points.

[0088] Specifically, a temporary calibration ruler (ruler_tmp) for the head shape point cur_point is created in m_ruler to store the temporary calibration ruler for the head shape point cur_point. n1 and n2 are created, and beams with endpoints n1 and n2 are created and placed into rule_tmp.

[0089] Optionally, calculating the distance between the head shape measurement point and the calibration ruler also includes:

[0090] Calculate the distance between the Z-axis projection line of the calibration ruler at the head shape point and the temporary calibration ruler;

[0091] Specifically, calculate the distance between the z-axis projection line of the calibration ruler at the head-shaped point, part_line, and the temporary calibration ruler, ruleer_tmp. Calculate the distance between part_line and ruleer_tmp, denoted as dist_line2tmpruler.

[0092] Establish a ruler for verifying the head shape points;

[0093] Specifically, a ruler for verifying the head-shaped point cur_point is created in m_ruler. n11 and n22 are created, and beams with endpoints n11 and n22 are added to the ruler.

[0094] The distance between the head shape measurement point and the calibration ruler is calculated using Heron's formula. According to Heron's formula, the area *s* of the triangle formed by the head shape measurement point, n11, and n22 can be calculated. The Heron's formula is as follows: ; ;

[0095] in, The length of the triangle is half its perimeter, i.e. ( + + ) / 2; To check the length of the ruler; The distance between the head shape point to be measured and the endpoint n11 of the calibration ruler; The distance between the head shape point to be measured and the endpoint n22 of the calibration ruler; This is the distance between the head shape point to be tested and the calibration ruler.

[0096] As an optional implementation of the above embodiments, the following steps are taken:

[0097] Step 1: Open the automation script. The method is as follows: In the PRIMER software, select and open the automation script through "Tools | Script". The automation script interface is as follows: Figure 4 As shown.

[0098] Step 2: Select the pedestrian protection simulation model. The method is as follows: Click the "select" button after the automation script "1. bonnet model", select the pedestrian protection simulation model, and assign it to the variable m_cas.

[0099] Step 3: Select the head shape point file. The method is as follows: Click the "select" button after "2. points list file" in the automation script, and select the head shape point file (file format as follows). Figure 5 As shown), identify all head shape points in the head shape point file and put them into the array points_all. This step is automated using JavaScript in the PRIMER software through secondary development. The automation steps are as follows:

[0100] Use "var chars = f.ReadChar('D / primer_pedmarkup_head.log')" to read the contents of the head point file 'D / primer_pedmarkup_head.log' and assign the value to the variable chars.

[0101] Use "var lines = chars.split('\n')" to get an array consisting of each line of the header file and assign it to the variable lines.

[0102] Use "for (var i=0;i< lines.length;i++)" to iterate through the array lines, use "var points_all[i].name = lines[i].split[0]" to get the name of the i-th head shape point, use "var points_all[i].x = lines[i].split[1]" to get the x-coordinate of the i-th head shape point, use "var points_all[i].y =lines[i].split[2]" to get the y-coordinate of the i-th head shape point, and use "var points_all[i].z = lines[i].split[3]" to get the z-coordinate of the i-th head shape point.

[0103] The array points_all is obtained. All elements in points_all are objects, and each object has the following attributes: head shape point name, head shape point x coordinate, head shape point y coordinate, and head shape point z coordinate.

[0104] Step 4: Select the shell elements of the verification region. The method is as follows: Click the "select" button after the automation script "3. shells onbonnet" to select the shell elements of the verification region; add the shell elements of the verification region to the set_shell. This step is automated using JavaScript in the PRIMER software through secondary development. The automation steps are as follows:

[0105] Use "var f_shell = AllocateFlag()" to create the label f_shell.

[0106] Use "Shell.Select(f_shell, 'Select shells on bonnet', m_cas, 0)" to select shell units and label the selected shell units with the tag f_shell.

[0107] Use "set_shell = new Set(m_cas, Set.NextFreeLabel(m_cas, Set.SHELL),Set.SHELL)" to create a shell cell set set_shell.

[0108] Use "set_shell.AddFlagged(f_shell)" to add shell units labeled f_shell to the set_shell.

[0109] Get the set_shell.

[0110] Step 5. Check the side reference line of the engine hood. The method is as follows: Click the "check" button after the automation script "4. check bonnet" to check the side reference line of the engine hood. This step is implemented by secondary development in the PRIMER software using the JavaScript language to achieve automation. The automation steps are as follows:

[0111] Step 5.1. Use "var points_on_shells = new Array()" to create an array points_on_shells to store the head type points in the checking area.

[0112] Step 5.2. Determine whether the array points_all is empty; if it is not empty, go to Step 5.3; if it is empty, go to Step 5.4.

[0113] Step 5.3. Take the first head type point from points_all and denote it as cur_point. Determine whether the z-projection of cur_point falls within the z-projection of set_shell; if the z-projection of cur_point is within the z-projection of set_shell, put cur_point into points_on_shells; if the z-projection of cur_point is not within the z-projection of set_shell, return to Step 5.2. The method for determining whether the z-projection of cur_point falls within the z-projection of set_shell is as follows:

[0114] Use "for (var i=0; i<set_shell;i++)" to traverse the set set_shell, and any shell element of set_shell can be denoted as set_shell[i].

[0115] Assume the minimum x-coordinate of `set_shell[i]` is 9999 (which can be understood as positive infinity), and assign it to the variable `x_min`. Use `var n1 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n1)` to get the first node `n1` of the shell unit `set_shell[i]`. If the x-coordinate of node `n1`, "n1.x", is less than `x_min`, update the value of `x_min` to "n1.x". Use `var n2 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n2)` to get the first node `n2` of the shell unit `set_shell[i]`. If the x-coordinate of node `n2`, "n2.x", is less than `x_min`, update the value of `x_min` to "n2.x". Use `var n3 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, ...)` to get the first node `n2` of the shell unit `set_shell[i]`. If the x-coordinate of node `n2`, "n2.x", is less than `x_min`, update the value of `x_min` to "n2.x". `set_shell[i].label).n3)` retrieves the first node n3 of the shell unit `set_shell[i]`. If the x-coordinate of node n3, "n3.x", is less than x_min, the value of x_min is updated to "n3.x". `var n4 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n4)` retrieves the first node n4 of the shell unit `set_shell[i]`. If the x-coordinate of node n4, "n4.x", is less than x_min, the value of x_min is updated to "n4.x".

[0116] Assume the maximum x-coordinate of `set_shell[i]` is -9999 (which can be understood as negative infinity), and assign it to the variable `x_max`. Use `var n1 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n1)` to get the first node `n1` of the shell unit `set_shell[i]`. If the x-coordinate of node `n1`, "n1.x", is greater than `x_max`, update the value of `x_max` to "n1.x". Use `var n2 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n2)` to get the first node `n2` of the shell unit `set_shell[i]`. If the x-coordinate of node `n2`, "n2.x", is greater than `x_max`, update the value of `x_max` to "n2.x". Use `var n3 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, ...)` to get the first node `n2` of the shell unit `set_shell[i]`. If the x-coordinate of node `n2`, "n2.x", is greater than `x_max`, update the value of `x_max` to "n2.x". `set_shell[i].label).n3)` retrieves the first node `n3` of the shell unit `set_shell[i]`. If the x-coordinate of node `n3`, "n3.x", is greater than `x_max`, the value of `x_max` is updated to "n3.x". `var n4 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n4)` retrieves the first node `n4` of the shell unit `set_shell[i]`. If the x-coordinate of node `n4`, "n4.x", is greater than `x_max`, the value of `x_max` is updated to "n4.x".

[0117] Assume the minimum y-coordinate of `set_shell[i]` is 9999 (which can be understood as positive infinity), and assign it to the variable `y_min`. Use `var n1 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n1)` to get the first node `n1` of the shell unit `set_shell[i]`. If the y-coordinate of node `n1`, "n1.y", is less than `y_min`, update the value of `y_min` to "n1.y". Use `var n2 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n2)` to get the first node `n2` of the shell unit `set_shell[i]`. If the y-coordinate of node `n2`, "n2.y", is less than `y_min`, update the value of `y_min` to "n2.y". Use `var n3 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, ...)` to get the first node `n2` of the shell unit `set_shell[i]`. If the y-coordinate of node `n2`, "n2.y", is less than `y_min`, update the value of `y_min` to "n2.y". `set_shell[i].label).n3)` retrieves the first node n3 of the shell unit `set_shell[i]`. If the y-coordinate of node n3, "n3.y", is less than y_min, the value of y_min is updated to "n3.y". `var n4 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n4)` retrieves the first node n4 of the shell unit `set_shell[i]`. If the y-coordinate of node n4, "n4.y", is less than y_min, the value of y_min is updated to "n4.y".

[0118] Assume the maximum y-coordinate of `set_shell[i]` is -9999 (which can be understood as negative infinity), and assign it to the variable `y_max`. Use `var n1 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n1)` to get the first node `n1` of the shell unit `set_shell[i]`. If the y-coordinate of node `n1`, "n1.y", is greater than `y_max`, update the value of `y_max` to "n1.y". Use `var n2 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n2)` to get the first node `n2` of the shell unit `set_shell[i]`. If the y-coordinate of node `n2`, "n2.y", is greater than `y_max`, update the value of `y_max` to "n2.y". Use `var n3 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, ...)` to get the first node `n2` of the shell unit `set_shell[i]`. If the y-coordinate of node `n2`, "n2.y", is greater than `y_max`, update the value of `y_max` to "n2.y". `set_shell[i].label).n3)` retrieves the first node n3 of the shell unit `set_shell[i]`. If the y-coordinate of node n3, "n3.y", is greater than y_max, the value of y_max is updated to "n3.y". `var n4 = Node.GetFromID(m_cas, Shell.GetFromID(m_cas, set_shell[i].label).n4)` retrieves the first node n4 of the shell unit `set_shell[i]`. If the y-coordinate of node n4, "n4.y", is greater than y_max, the value of y_max is updated to "n4.y".

[0119] If cur_point.x ≥ x_min and cur_point.x ≤ x_max and cur_point.y ≥ y_min and cur_point.y ≤ y_max, then the z-direction projection of cur_point lies within the z-direction head shape of set_shell.

[0120] Step 5.4: Check if the array points_on_shells is empty; if it is not empty, proceed to step 5.5; if it is empty, end the process.

[0121] Step 5.5: Retrieve the first head-shaped point from points_on_shells and denote it as cur_point.

[0122] Step 5.6: Establish an array arr_points using "var arr_points = new Array()" to store the head shape points and the verification distances.

[0123] Step 5.7: Establish a verification ruler for cur_point, denoted as ruler. The method for establishing the verification ruler ruler for the head shape point cur_point is as follows:

[0124] Establish a model m_ruler for storing the verification ruler. Use "var m_ruler = new Model(Model.Total()+1)" to establish a new simulation model m_ruler for storing the verification ruler.

[0125] Establish an array, denoted as shell_box, for storing the shell elements intersecting the longitudinal section passing through the head shape point. Use "var shell_box = new Array()" to establish an empty array shell_box for storing the shell elements intersecting the longitudinal section passing through the head shape point points_on_shells[i]. Use "var shell_cas = Shell.GetAll(m_cas)" to obtain all the shell elements of the pedestrian protection simulation model and put them into the array shell_cas. Use "for (var k=0;k<shell_cas.length;k++)" to traverse the array shell_cas composed of all the shell elements of the pedestrian protection simulation model. Any shell element of shell_cas can be denoted as shell_cas[k]. Obtain the minimum value x_min of the x coordinate, the maximum value x_max of the x coordinate, and the minimum value y_min of the y coordinate of shell_cas[k]. The method used in this embodiment is the same as that in Step 5.3 and will not be elaborated here. If x_min ≤ points_on_shells[i].x and x_max ≥ points_on_shells[i].x and y_min ≤ 0, then put the shell element shell_cas[k] into the array shell_box.

[0126] Establish the z - direction projection line of the calibration ruler at the head - shape point, denoted as part_line. Use "var part_line = new Part(m_ruler, Part.LastFreeLabel(m_ruler), Section.LastFreeLabel(m_ruler), Material.LastFreeLabel(m_ruler), 'beam')" to establish an empty part for storing the z - direction projection line of the calibration ruler at the head - shape point, denoted as part_line. Use "var cs = new CrossSection(m_cas,CrossSection.PLANE, Set.LastFreeLabel(m_cas, Set.PART),point_x, point_y - 0.5 * 5000, point_z - 0.5 * 5000, point_x + 10, point_y - 0.5 * 5000, point_z - 0.5 * 5000,point_x, point_y - 0.5 * 5000 + 1000, point_z - 0.5 * 5000,5000, 5000, 0, 0,CrossSection.LastFreeLabel(m_cas))" to establish a CrossSection of the longitudinal section passing through the collision point in the pedestrian protection simulation model, denoted as cs. Use "for (var j = 0;j < shell_box.length;j++)" to traverse all the shell elements of shell_box, and any shell element of shell_box can be denoted as shell_box [j]. Use "var data = shell_box[j].ElemCut(cs.label)" to calculate the intersection information between cs and shell_box[j] and put it into the array data. The array data has 6 elements, which are: the x - coordinate of the first intersection point, the y - coordinate of the first intersection point, the z - coordinate of the first intersection point, the x - coordinate of the second intersection point, the y - coordinate of the second intersection point, and the z - coordinate of the second intersection point.The first intersection point n1 is established using "var n1 = new Node(m_ruler,Node.LastFreeLabel(m_ruler), parseFloat(data[0]), parseFloat(data[1]),parseFloat(data[2]))", the second intersection point n2 is established using "var n2 = new Node(m_ruler,Node.LastFreeLabel(m_ruler), parseFloat(data[3]), parseFloat(data[4]),parseFloat(data[5]))", and a beam with endpoints n1 and n2 is established using "var beam = new Beam(m_ruler,Beam.LastFreeLabel(m_ruler),part_line.label, n1.label, n2.label)" and placed into part_line.

[0127] Create a temporary ruler `ruler_tmp` for the head shape point `cur_point`. Use the expression `var ruler_tmp = newPart(m_ruler, Part.LastFreeLabel(m_ruler), Section.LastFreeLabel(m_ruler), Material.LastFreeLabel(m_ruler), 'beam_tmp')` to create `ruler_tmp` within `m_ruler`. This temporary ruler `ruler_tmp` will be used to store the head shape point `cur_point`. Create node n1 using "var n1 = new Node(m_ruler,Node.LastFreeLabel(m_ruler), point_x, -9999, 0)"; create node n2 using "var n2 = new Node(m_ruler, Node.LastFreeLabel(m_ruler), point_x, 0, n1.z+9999)"; create a beam with endpoints n1 and n2 using "var beam = new Beam(m_ruler, Beam.LastFreeLabel(m_ruler), ruler_tmp.label,n1.label, n2.label)" and put it into ruler_tmp.

[0128] Calculate the distance between the z-axis projection line of the calibration ruler at the head-shaped point, part_line, and the temporary calibration ruler, ruleer_tmp. Use "var dist_line2tmpruler = Part.MeasurePartToPart(part_line, ruler_tmp)" to calculate the distance between part_line and ruleer_tmp, and denote it as dist_line2tmpruler.

[0129] Create a ruler for the head shape point cur_point. Use "var ruler = new Part(m_ruler, Part.LastFreeLabel(m_ruler), Section.LastFreeLabel(m_ruler),Material.LastFreeLabel(m_ruler))" to create a ruler in m_ruler, which will be used to store the ruler for the head shape point cur_point. The code `var n11 = new Node(m_ruler, Node.LastFreeLabel(m_ruler),cur_point.x, -9999+dist_line2tmpruler / Math.cos(45 / 180*Math.PI), 0)` creates node `n11`, `var n22 = new Node(m_ruler, Node.LastFreeLabel(m_ruler), cur_point.x, 0,n11.z+9999- dist_line2tmpruler / Math.cos(45 / 180*Math.PI))` creates node `n22`, and `var beam = new Beam(m_ruler, Beam.LastFreeLabel(m_ruler), ruler.label, n11.label,n22.label)` creates a beam with endpoints `n11` and `n22` and places it into the `ruler`.

[0130] Calculate the distance between cur_point and ruler. The distance (ha) between the head shape point cur_point and the check ruler can be calculated using Heron's formula. The principle is as follows: Figure 6As shown. The length *a* of the ruler is calculated using "var a = Math.sqrt(Math.pow(n11.x-n22.x,2) + Math.pow(n11.y-n22.y,2) + Math.pow(n11.z-n22.z,2) )". The distance *b* between the head shape point *cur_* and the endpoint *n11* of the ruler is calculated using "var b = Math.sqrt(Math.pow(n11.x-cur_point.x,2) + Math.pow(n11.y-cur_point.y,2) + Math.pow(n11.z-cur_point.z,2) )". The distance *b* between the head shape point *cur_* and the endpoint *n11* of the ruler is calculated using "var c = Math.sqrt(Math.pow(n22.x-cur_point.x,2) + Math.pow(n22.y-cur_point.y,2) + The code `Math.pow(n22.z-cur_point.z,2) )` calculates the distance `c` between the head-shaped point `cur_` and the endpoint `n22` of the check ruler. It then uses `var p = (a + b + c) / 2` to calculate the semi-perimeter `p` of the triangle formed by `cur_point`, `n11`, and `n22`. Finally, it uses `var ha = 2 * s / a` to calculate the distance `ha` between `cur_point` and the ruler.An empty object `obj_point` is created using `var obj_point = new Object()` to store the head shape point `cur_point` information and verification results. The `x` property of `obj_point` is set to the x-coordinate of the head shape point `cur_point` using `obj_point.x = cur_point.x`, the `y` property is set to the y-coordinate of the head shape point `cur_point` using `obj_point.y = cur_point.y`, the `z` property is set to the z-coordinate of the head shape point `cur_point` using `obj_point.z = cur_point.z`, and the `dist_y` property is set to the y-coordinate of the head shape point `cur_point` using `obj_point.dist_y = ha / Math.cos(45 / 180*Math.PI)`. The `dist_y` property of `obj_point` is the y-distance between the head shape point `cur_point` and the verification ruler. Finally, `obj_point.dist_z = ...` is used to... "ha / Math.sin(45 / 180*Math.PI)" sets the dist_z property of obj_point to the distance in the z-direction between the head-shaped point cur_point and the check ruler. "obj_point.name = point_name" sets the name property of obj_point to the name of the head-shaped point cur_point. "arr_points.push(obj_point)" puts the object obj_point into the array arr_points.

[0131] Optionally, displaying the verification results may also include:

[0132] Label the head shape location names;

[0133] Specifically, an array is created to store the head shape points and the verification distance. All head shape points in the array are traversed, and a solid circle is drawn for any head shape point in the array. The point name of the drawn head shape point is labeled.

[0134] The Z-axis direction of the marked portrait points is used to check the distance;

[0135] Specifically, iterate through all head shape points in the array, draw an auxiliary line for the z-axis verification distance of any head shape point in the array, and label the drawn z-axis verification distance of the head shape point.

[0136] The Y-axis direction of the marked head shape points is used for verification distance;

[0137] Traverse all the head shape points in the array, draw an auxiliary line for the y-direction verification distance of any head shape point in the array, and mark the y-direction verification distance of the drawn head shape point.

[0138] Draw the verification result.

[0139] Specifically, use "Graphics.Finish()" to end the drawing of the verification result, and the verification result is as Figure 7 shown.

[0140] As an optional implementation of the above embodiments of drawing the verification result, the following steps:

[0141] Use "Graphics.Start()" to start drawing the verification result.

[0142] Use "for(var k=0;k<arr_points.length;k++)" to traverse all the head shape points in the array arr_points, and any head shape point in arr_points can be denoted as arr_points[k]; use "Graphics.MoveTo(arr_points[k].x, arr_points[k].y, arr_points[k].z); Graphics.Shape(Graphics.FILLED_CIRCLE, 20)" to draw a solid circle with a size of 20 mm at the head shape point arr_points[k]; use "Graphics.Text(arr_points[k].name)" to mark the point name of the head shape point arr_points[k].

[0143] Use "for(var k=0;k<arr_points.length;k++)" to traverse all the head shape points in the array arr_points, and any head shape point in arr_points can be denoted as arr_points[k]; use "Graphics.LineStyle(Graphics.DASH_LINE); Graphics.Line(arr_points[k].x, arr_points[k].y, arr_points[k].z,arr_points[k].x, arr_points[k].y, arr_points[k].z + arr_points[k].dist_z);" to draw the auxiliary line of the z-direction verification distance of the head shape point arr_points[k]; use "Graphics.MoveTo(arr_points[k].x, arr_points[k].y, arr_points[k].z + arr_points[k].dist_z / 2); Graphics.Text('z: '+ String(arr_points[k].dist_z.toFixed(1)) +' mm')" to label the z-direction verification distance of the head shape point arr_points[k].

[0144] Use "for(var k=0;k<arr_points.length;k++)" to traverse all the head shape points in the array arr_points, and any head shape point in arr_points can be denoted as arr_points[k]; use "Graphics.LineStyle(Graphics.DASH_LINE); Graphics.Line(arr_points[k].x, arr_points[k].y, arr_points[k].z, arr_points[k].x, arr_points[k].y - arr_points[k].dist_y, arr_points[k].z);" to draw the auxiliary line of the y-direction verification distance of the head shape point arr_points[k]; use "Graphics.MoveTo(arr_points[k].x, arr_points[k].y - arr_points[k].dist_y / 2,arr_points[k].z); Graphics.Text('y: '+ String(arr_points[k].dist_z.toFixed(1)) +' mm')" to mark the y-direction verification distance of the head shape point arr_points[k].

[0145] Use "Graphics. Finish ()" to end the drawing of the verification result.

[0146] On the other hand, as Figure 2 shown, a side reference line verification device for an engine hood is provided, including:

[0147] An acquisition module 16, the acquisition module is used to acquire a pedestrian protection simulation model and a head shape point file, the pedestrian protection simulation model includes verification shell units in the verification area, and the head shape point file includes multiple head shape point information;

[0148] Specifically, the pedestrian protection simulation model is a component simulation model used to test the impact of a vehicle on pedestrian protection performance. It includes the three-dimensional spatial data of the components. Head impact points refer to the simulated collision positions and angles of a child's or adult's head with the vehicle's hood or other components during pedestrian protection testing. Different head impact points have different mass, velocity, and collision angle requirements, and are one of the important indicators for evaluating a vehicle's pedestrian protection performance. A head impact point file is a file containing multiple head impact point information points used to simulate the positions a pedestrian's head might come into contact with during a collision. The head impact point information includes the X, Y, and Z coordinates of the pedestrian's head and the hard-point component in the same coordinate system. Because the C-NCAP management rules (2021 version) pedestrian protection test method stipulate that when marking the baseline on the side of the hood, the ruler only needs to contact the hood or fender; therefore, the pedestrian protection simulation model selected for this step only includes the hood and fender.

[0149] Verification module 17 is used to determine whether the projection of the head shape point in the Z-axis direction falls within the projection of the verification shell unit in the Z-direction. If it falls within the projection of the verification shell unit in the Z-direction, the head shape point is the head shape point to be measured, and a simulation model for storing the verification ruler is established.

[0150] Specifically, this step includes identifying head shape points in the verification area, modeling the head shape point verification ruler, and calculating the distance between the head shape points and the verification ruler. It quickly identifies risk points in the pedestrian protection head shape test, optimizes the points through shape optimization, and improves the pedestrian protection score rate; it achieves accurate verification of the engine hood side baseline with 100% accuracy; and it achieves rapid verification of the engine hood side baseline.

[0151] Calculation module 18, the calculation module is used to calculate the distance between the head shape point to be measured and the calibration ruler;

[0152] Output module 19 displays the verification results.

[0153] Specifically, by displaying the verification results, the position of the head point of the engine hood side baseline and the position of the head point verification ruler, as well as the distance between the head point and the verification ruler, are marked, thereby providing technical support for the subsequent improvement of the engine hood side baseline layout.

[0154] On the other hand, such as Figure 8 As shown, an electronic device is provided, the electronic device comprising:

[0155] One or more processors 11;

[0156] Storage device for storing one or more programs.

[0157] When the one or more programs are executed by the one or more processors 11, the one or more processors 11 implement an engine hood side baseline verification method as described above.

[0158] Specifically, the storage device includes a memory 10, a processor (CPU) 11, and a computer program 14. The computer program 14 is stored in the memory 10, and the processor 11 executes the computer program 14 to implement the automatic compensation method for robot glue application described in any of the above-mentioned embodiments. The control system also includes a communication interface 13 and a communication bus 12. The processor 11, communication interface 13, and memory 10 communicate via the communication bus 12. The communication bus 12 can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. If the memory 10, processor 11, and communication interface 13 are integrated onto a single chip, they can communicate with each other through an internal interface.

[0159] The processor 11 may also be a specific integrated circuit or multiple integrated circuits.

[0160] On the other hand, such as Figure 8 As shown, a computer-readable storage medium 15 is provided, on which a computer program 14 is stored, which, when executed by a processor 11, implements a method for verifying the side baseline of an engine hood as described above.

[0161] Specifically, computer program 14 may include program code, which includes computer operation instructions; memory 10, for storing computer program 14. Memory 10 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage; communication interface 13, for communicating with other network elements such as clients or other servers.

[0162] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for verifying the baseline of the side of an engine hood, characterized in that, include: Select a pedestrian protection simulation model; Select a head shape point file, which includes multiple head shape point information, wherein the head shape point information includes three-dimensional spatial coordinate information; Select the verification shell unit for the verification area; The calibration of the baseline on the side of the engine hood includes: determining whether the projection of the head shape point in the Z-axis direction falls within the Z-direction projection of the calibration shell unit; if it falls within the Z-direction projection of the calibration shell unit, then the head shape point is the head shape point to be measured; establishing a simulation model that stores the calibration ruler; and calculating the distance between the head shape point to be measured and the calibration ruler. The maximum value of the verification shell unit in the positive X-axis direction is set as x_max, the minimum value in the negative X-axis direction is set as x_min, the maximum value in the positive Y-axis direction is set as y_max, and the minimum value in the negative X-axis direction is set as y_min. Let the coordinates of the head shape point be (x, y, z). When x_min≤x≤x_max and y_min≤y≤y_max, the projection of the head shape point in the Z-axis direction falls within the projection of the verification shell unit in the Z direction. Among them, establishing a simulation model for storing and verifying the ruler includes: establishing a model for storing and verifying the ruler; Establish an array to store the shell elements that intersect with the longitudinal section of the head shape point; establish an array to store the projection line of the check ruler in the Z-axis direction of the head shape point; establish a temporary check ruler for the head shape point; Display the verification results.

2. The method for verifying the side baseline of an engine hood according to claim 1, characterized in that, After selecting the head shape point file, the following are also included: Create a head shape array. Identify all head shape points in the head shape point file and put them into the head shape array. All elements in the head shape array are objects, and each object has the following attributes: head shape point name, head shape point x coordinate, head shape point y coordinate, and head shape point z coordinate.

3. The method for verifying the side baseline of an engine hood according to claim 1, characterized in that, The verification shell unit for selecting the verification area also includes: A verification area is set up, wherein the verification area is the engine hood and fender; Establish a set of verification shell elements and put the verification shell elements of the verification region into the set of verification shell elements.

4. The method for verifying the side baseline of an engine hood according to claim 1, characterized in that, Calculating the distance between the head shape measurement point and the calibration ruler also includes: Calculate the distance between the Z-axis projection line of the calibration ruler at the head shape point and the temporary calibration ruler; Establish a ruler for verifying the head shape points; The distance between the head shape measurement point and the calibration ruler is calculated using Heron's formula. According to Heron's formula, the area *s* of the triangle formed by the head shape measurement point, n11, and n22 can be calculated. The Heron's formula is as follows: ； ； in, The length of the triangle is half its perimeter, i.e. ( + + ) / 2; To check the length of the ruler; The distance between the head shape point to be measured and the endpoint n11 of the calibration ruler; The distance between the head shape point to be measured and the endpoint n22 of the calibration ruler; This is the distance between the head shape point to be tested and the calibration ruler.

5. The method for verifying the baseline of the engine hood side as described in claim 4, characterized in that, The verification results also include: Label the head shape location names; The Z-axis direction of the marked portrait points is used to check the distance; The Y-axis direction of the marked head shape points is used for verification distance; Draw the verification results.

6. A device for verifying the side baseline of an engine hood, using the method for verifying the side baseline of an engine hood as described in any one of claims 1 to 5, characterized in that, include: The acquisition module is used to acquire a pedestrian protection simulation model and a head shape location file. The pedestrian protection simulation model includes a verification shell unit for the verification area, and the head shape location file includes multiple head shape location information. The verification module is used to determine whether the projection of the head shape point in the Z-axis direction falls within the projection of the verification shell unit in the Z-direction. If it falls within the projection of the verification shell unit in the Z-direction, the head shape point is the head shape point to be tested, and a simulation model for storing the verification ruler is established. The calculation module is used to calculate the distance between the head shape point to be measured and the calibration ruler; The output module displays the verification results.

7. An electronic device, characterized in that, The electronic device includes: One or more processors; Storage device for storing one or more programs. When the one or more programs are executed by the one or more processors, the one or more processors implement a method for verifying the side baseline of an engine hood as described in any one of claims 1 to 5.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by the processor, the program implements a method for verifying the side baseline of an engine hood as described in any one of claims 1 to 5.

Images