Kanzi engine-based intelligent driving assistance system obstacle display method and device
The intelligent driving assistance system of the Kanzi engine dynamically displays obstacles by utilizing object pooling mechanisms and rendering logic, solving the problem of poor adaptability of traditional obstacle icons and achieving efficient visual design and enhanced safety.
Patent Information
- Application Number
- CN202611312091.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-27
- Publication Date
- 2026-11-17
AI Technical Summary
Traditional obstacle icons lack a sense of three-dimensionality and dynamic effects, making it difficult to quickly adapt to the visual design needs of different car models and brands, resulting in a large workload for development.
The intelligent driving assistance system based on the Kanzi engine acquires obstacle perception data through a standardized data interface, dynamically schedules visual prefabs using an object pool mechanism, and performs dynamic rendering and display in conjunction with the rendering logic of the Kanzi engine. It supports switching between dynamic and static modes and realizes a three-dimensional interactive scene.
It improves the development efficiency and adaptability of obstacle display, reduces repetitive development work, provides smooth dynamic effects and rich interaction, and enhances driving safety and technological feel.
Smart Images

Figure CN123114403A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of vehicle driver assistance technology, specifically relating to an obstacle display method and device for an intelligent driving assistance system based on the Kanzi engine. Background Technology
[0002] With the rapid development of Advanced Driver Assistance Systems (ADAS) and autonomous driving technologies, vehicle perception systems (such as radar, cameras, and lidar) can detect obstacles in the surrounding environment in real time. Presenting this perception data to the driver clearly, intuitively, and aesthetically is crucial for improving driving safety and user experience.
[0003] However, traditional obstacle icons are usually static or simply animated 2D images, which have poor integration with the real environment, lack a sense of three-dimensionality and dynamic effects. Moreover, the UI design styles of different car models and brands vary greatly, and existing solutions are difficult to quickly adapt to different visual design needs (such as color, material, and animation effects), requiring a lot of repetitive development work. Summary of the Invention
[0004] To improve the development efficiency, adaptability, and dynamism of obstacle display, a first aspect of the present invention provides an intelligent driving assistance system based on the Kanzi engine, comprising: acquiring obstacle perception data accessed through a standardized data interface, the obstacle perception data including obstacle identifiers and state characteristics; detecting the update status of the obstacle perception data in real time through a node attribute monitoring mechanism; parsing the obstacle perception data in response to the detected data update; dynamically scheduling corresponding visual prefabs for instantiation within a preset rendering boundary using an object pool mechanism; updating the attributes of the visual prefabs according to the parsed state characteristics; and executing the dynamic rendering display of the visual prefabs by rewriting the rendering logic of the Kanzi engine.
[0005] In some embodiments of the present invention, the step of dynamically scheduling the corresponding visual prefab for instantiation using the object pool mechanism includes: checking whether the identifier of the obstacle exists in the active node table; if it does not exist, retrieving and reusing a visual prefab matching the obstacle type from the backup node pool; if the backup node pool is empty, loading the corresponding visual prefab template to instantiate a new visual prefab and adding it to the active node table.
[0006] In some embodiments of the present invention, before updating the attributes of the visualized prefab based on the parsed state features, the method further includes: extracting the first coordinate of the visualized prefab in the previous frame and the second coordinate of the current frame obtained by parsing from the obstacle perception data; calculating the difference between the first coordinate and the second coordinate, and determining whether the difference exceeds a preset threshold; if it exceeds the preset threshold, determining that a positional change has occurred, and performing smooth transition processing on the movement trajectory of the visualized prefab.
[0007] In some embodiments of the present invention, parsing the obstacle perception data includes: reading the mode attribute identifier to determine whether the current operating mode is dynamic or static; binding the obstacle perception data to the corresponding hierarchical root node according to the determined operating mode; and extracting the corresponding fields from the obstacle perception data according to the preset field extraction rules corresponding to the operating mode.
[0008] Furthermore, the parsing process also includes an obstacle quantity limit: the number of obstacles parsed is counted in real time during the parsing process; when the number of targets parsed reaches the upper limit of the number of obstacles, the parsing of subsequent obstacle perception data is stopped; and the parsed target data is stored in the target data mapping table.
[0009] In some embodiments of the present invention, the method further includes constructing a three-dimensional interactive scene: configuring clickable attributes and triggers for the instantiated visual prefab; in response to a touch trigger event on the visual prefab, publishing a message carrying the obstacle identifier; after the business logic layer subscribes to and receives the message, obtaining detailed information about the obstacle, and driving the information panel node to display information.
[0010] A second aspect of the present invention provides an obstacle display device for an intelligent driving assistance system based on the Kanzi engine, comprising: an acquisition module for acquiring obstacle perception data accessed through a standardized data interface, the obstacle perception data including obstacle identifiers and state characteristics; a detection module for detecting the update status of the obstacle perception data in real time through a node attribute monitoring mechanism; a parsing module for parsing the obstacle perception data in response to the detected data update; dynamically scheduling corresponding visual prefabs for instantiation within a preset rendering boundary using an object pool mechanism; and a rendering module for updating the attributes of the visual prefabs according to the parsed state characteristics, and performing dynamic rendering display of the visual prefabs by rewriting the rendering logic of the Kanzi engine.
[0011] A third aspect of the present invention provides an electronic device comprising: one or more processors; and a storage device for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement the obstacle display method for an intelligent driving assistance system based on the Kanzi engine provided in the first aspect of the present invention.
[0012] In a fourth aspect, the present invention provides a computer-readable medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the obstacle display method for an intelligent driving assistance system based on the Kanzi engine provided in the first aspect of the present invention.
[0013] The beneficial effects of this invention are: This invention aims to overcome the shortcomings of existing technologies and provide an obstacle avoidance plugin for intelligent driving assistance systems based on the Kanzi engine. It encapsulates real-time obstacle display functionality, provides standardized interfaces, and can be reused in the development of various intelligent driving assistance systems, significantly saving development time. Compared to previous technologies, HMI engineers can perform WYSIWYG configuration and design through KanziStudio using standardized interfaces. 90% of the visual and animation work requires no coding; developers only need to focus on data access and business logic. As a native Kanzi plugin, it offers high rendering efficiency and low performance overhead, providing smooth animations and rich interactions, enhancing driving safety and a sense of technology. Attached Figure Description
[0014] Figure 1 This is a basic flowchart illustrating the obstacle display method of an intelligent driving assistance system based on the Kanzi engine in some embodiments of the present invention; Figure 2 This is a schematic diagram illustrating the specific architecture of an obstacle display method for an intelligent driving assistance system based on the Kanzi engine in some embodiments of the present invention; Figure 3 This is a schematic diagram of the obstacle display device of an intelligent driving assistance system based on the Kanzi engine in some embodiments of the present invention; Figure 4 This is a schematic diagram of the structure of an electronic device in some embodiments of the present invention. Detailed Implementation
[0015] The principles and features of the present invention are described below with reference to the accompanying drawings. The examples given are only for explaining the present invention and are not intended to limit the scope of the present invention.
[0016] Example 1 refer to Figure 1 and Figure 2In a first aspect, the present invention provides an intelligent driving assistance system based on the Kanzi engine, comprising: S100. acquiring obstacle perception data accessed through a standardized data interface, the obstacle perception data including obstacle identification and state characteristics; S200. detecting the update status of the obstacle perception data in real time through a node attribute monitoring mechanism; S300. responding to the detected data update, parsing the obstacle perception data; and dynamically scheduling corresponding visual prefabs for instantiation within a preset rendering boundary using an object pool mechanism; S400. updating the attributes of the visual prefabs according to the parsed state characteristics, and executing the dynamic rendering display of the visual prefabs by rewriting the rendering logic of the Kanzi engine.
[0017] It's worth noting that the Kanzi Engine is a mass-produced, powerful, and continuously evolving automotive HMI development platform, primarily consisting of two core components: Kanzi Studio: a visual design tool used to create UIs, import 2D / 3D content, and export production files; and Kanzi Engine: a graphics and UI execution environment responsible for running the files generated by Kanzi Studio, supporting cross-platform deployment.
[0018] In step S100 of some embodiments of the present invention, obstacle perception data accessed through a standardized data interface is obtained, the obstacle perception data including the identification and status characteristics of the obstacle; Specifically, a standardized data binding interface is defined to receive obstacle perception data from vehicle buses (such as CAN, Ethernet) or middleware (such as ROS, AUTOSAR). The data format typically includes: obstacle ID, type (vehicle, pedestrian, bicycle, etc.), world coordinates (X, Y, Z), relative speed, heading angle, confidence level, and status (stationary, moving, hazardous).
[0019] Visual configuration: Drag multiple ObstacleInstances from the repository into the container. Configure the corresponding "obstacle type" (e.g., car, electric vehicle, pedestrian) for each instance.
[0020] Data Connection: In the application layer (C++) code, instantiate the data manager provided by the plugin. Set up a data callback function that calls the ObstaclePlugin::UpdateData(constObstacleList&list) target object management plugin interface when a new obstacle list is received from the vehicle network.
[0021] In step S200 of some embodiments of the present invention, the update status of the obstacle perception data is detected in real time through a node attribute monitoring mechanism. Read the initial Target_Data and trigger HandleTargetData() to parse it. When Target_Data is modified externally (e.g., the simulation system pushes new target data), trigger the attribute change callback (reread the Boundary (supports runtime boundary adjustment), call HandleTargetData() again to parse the new Target_Data, update m_mapTarget; set m_renderflag=true, and trigger the next frame rendering update).
[0022] In step S300 of some embodiments of the present invention, in response to the detected data update, the obstacle perception data is parsed; and the corresponding visual prefab is dynamically scheduled for instantiation within a preset rendering boundary using an object pool mechanism. The step of dynamically scheduling the corresponding visual prefab for instantiation using the object pool mechanism includes: checking whether the obstacle's identifier exists in the active node table; if it does not exist, retrieving and reusing a visual prefab matching the obstacle type from the backup node pool; if the backup node pool is empty, loading the corresponding visual prefab template to instantiate a new visual prefab and adding it to the active node table.
[0023] In step S300 of some embodiments of the present invention, parsing the obstacle perception data includes: S301. Reading the mode attribute identifier and determining whether the current operating mode is dynamic mode or static mode; Specifically, read the IsDynamic property to determine whether it is dynamic mode or static mode; S302. Based on the determined operating mode, bind the obstacle perception data to the corresponding hierarchical root node; Specifically, the root node is selected based on IsDynamic: #TargetRoot is bound to dynamic mode, and #TargetRoot_Static is bound to static mode; the PrefabsURL prefab path is read (this path is shared by dynamic and static modes, and can also be distinguished by configuration) to prepare for subsequent target instantiation; S303. Extract the corresponding fields from the obstacle perception data according to the preset field extraction rules corresponding to the operating mode.
[0024] Specifically, the initial Target_Data is read, triggering HandleTargetData() parsing. The Target_Data string is iterated through (format: [target1 field], [target2 field],...), and fields are parsed according to IsDynamic. Dynamic mode parses fields such as objectId, objectType, lightStatus, objectPoseX / Y, objectYaw, and objectColor; static mode parses fields such as objectId, objectType, objectPoseX / Y, objectYaw, and objectVelocityX / Y. Furthermore, the parsing process also includes an obstacle quantity limit: the number of obstacles parsed is counted in real time during the parsing process; when the number of targets parsed reaches the upper limit of the number of obstacles, the parsing of subsequent obstacle perception data is stopped; and the parsed target data is stored in the target data mapping table.
[0025] Specifically, the parsing process is limited by Target_Max: if the number of targets to be parsed exceeds Target_Max, parsing stops. The parsed target data is stored in m_mapTarget (ID-target data mapping table) to prepare for rendering.
[0026] In step S400 of some embodiments of the present invention, the attributes of the visual prefab are updated according to the parsed state features, and the dynamic rendering display of the visual prefab is executed by rewriting the rendering logic of the Kanzi engine.
[0027] The process of updating the properties of the visualized prefab based on the parsed state features also includes: Extract the first coordinate of the visualized prefab in the previous frame and the second coordinate of the current frame obtained by parsing the obstacle perception data; calculate the difference between the first coordinate and the second coordinate, and determine whether the difference exceeds a preset threshold; if it exceeds the preset threshold, determine that a positional change has occurred, and perform smooth transition processing on the movement trajectory of the visualized prefab.
[0028] Specifically, the `isJump` function is called to detect whether the target's position has changed (abruptly). `lastX / lastY`: The target's X / Y coordinates in the previous frame (read from 3D node attributes); `objectPoseX / objectPoseY`: The target's latest X / Y coordinates in the current frame (parsed from external data); `isJump` (implementation not shown, but inferred from logic): Determines whether the difference between the two coordinates exceeds a threshold (e.g., a sudden change in position exceeding a certain distance), returning `true` for a jump and `false` for normal movement.
[0029] In some embodiments of the present invention, the method further includes constructing a three-dimensional interactive scene: configuring clickable attributes and triggers for the instantiated visual prefab; in response to a touch trigger event on the visual prefab, publishing a message carrying the obstacle identifier; after the business logic layer subscribes to and receives the message, obtaining detailed information about the obstacle, and driving the information panel node to display information.
[0030] Specifically, in Kanzi Studio, select ObstacleInstance and check isClickable in the Properties panel. Then create a "Trigger" that defines how to publish a message when the instance triggers a TouchPress event. Developers subscribe to this message in their code, and when received, retrieve detailed information from the data layer based on the obstacle ID attached to the message, and control the display of another "Message Panel" node in the Kanzi project.
[0031] In one specific embodiment of the present invention, it includes: Step 1: Target_Data change triggers update onNodePropertyChanged; When Target_Data is modified externally (such as the simulation system pushing new target data), the property change callback is triggered (rereading the Boundary, supporting runtime boundary adjustment), HandleTargetData() is called again to parse the new Target_Data, and m_mapTarget is updated; m_renderflag is set to true, triggering the next frame rendering update.
[0032] Step 2: Rendering Phase: The core logic is to iterate through the target data in `m_mapTarget` and combine all attributes to complete rendering / recycling: Boundary is applied. For each target in `m_mapTarget`, calculate whether its `objectPoseX / Y` is within the Boundary range. Target node instantiation (PrefabsURL is applied): Check if the target ID already exists in `m_targetNodes` (active node table): If not, prioritize reusing a prefab of the same type (`objectType`) from `m_backupNodes` (backup node pool) (loaded from `PrefabsURL`); if the backup pool is empty, load the prefab template via `PrefabsURL` and instantiate the new node.
[0033] Step 3: The plugin will automatically update the position, status and other attributes of all obstacle instances, thereby driving the UI update.
[0034] Step 4: Interactive Implementation. In Kanzi Studio, select ObstacleInstance and check isClickable in the Properties panel. Then create a "Trigger" that defines how a message is published when the instance triggers a TouchPress event. Developers subscribe to this message in their code. When received, the message retrieves detailed information from the data layer based on the obstacle ID attached to the message and controls the display of another "Message Panel" node in the Kanzi project.
[0035] Example 2 refer to Figure 3 In a second aspect, the present invention provides an obstacle display device 1 for an intelligent driving assistance system based on the Kanzi engine, comprising: an acquisition module 11, configured to acquire obstacle perception data accessed through a standardized data interface, the obstacle perception data including obstacle identifiers and state characteristics; a detection module 12, configured to detect the update status of the obstacle perception data in real time through a node attribute monitoring mechanism; a parsing module 13, configured to parse the obstacle perception data in response to the detected data update; and to dynamically schedule corresponding visual prefabs for instantiation within a preset rendering boundary using an object pool mechanism; and a rendering module 14, configured to update the attributes of the visual prefabs according to the parsed state characteristics, and to execute the dynamic rendering display of the visual prefabs by rewriting the rendering logic of the Kanzi engine.
[0036] Furthermore, the parsing module 13 includes: a determining unit, used to read the mode attribute identifier and determine whether the current operating mode is a dynamic mode or a static mode; a binding unit, used to bind the obstacle perception data to the corresponding hierarchical root node according to the determined operating mode; and an extraction unit, used to extract the corresponding fields from the obstacle perception data according to the preset field extraction rules corresponding to the operating mode.
[0037] Example 3 refer to Figure 4 A third aspect of the present invention provides an electronic device comprising: one or more processors; and a storage device for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement the obstacle display method of the intelligent driving assistance system based on the Kanzi engine of the first aspect of the present invention.
[0038] Electronic device 500 may include a processing unit (e.g., a central processing unit, a graphics processing unit, etc.) 501, which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 502 or a program loaded from storage device 508 into random access memory (RAM) 503. The RAM 503 also stores various programs and data required for the operation of electronic device 500. The processing unit 501, ROM 502, and RAM 503 are interconnected via bus 504. An input / output (I / O) interface 505 is also connected to bus 504.
[0039] Typically, the following devices can be connected to I / O interface 505: input devices 506 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 507 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 508 including, for example, hard disks; and communication devices 509. Communication device 509 allows electronic device 500 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 4 An electronic device 500 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively. Figure 4 Each box shown can represent a device or multiple devices as needed.
[0040] Specifically, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device 509, or installed from a storage device 508, or installed from a ROM 502. When the computer program is executed by a processing device 501, it performs the functions defined in the methods of embodiments of this disclosure. It should be noted that the computer-readable medium described in embodiments of this disclosure can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In embodiments of this disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in connection with an instruction execution system, apparatus, or device. In embodiments of this disclosure, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. Program code contained on a computer-readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.
[0041] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device. The aforementioned computer-readable medium carries one or more computer programs, which, when executed by the electronic device, cause the electronic device to: Computer program code for performing the operations of embodiments of this disclosure can be written in one or more programming languages or a combination thereof. Programming languages include object-oriented programming languages—such as Java, Smalltalk, C++, and Python—and conventional procedural programming languages—such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).
[0042] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.
[0043] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.
Claims
1. A method for obstacle display in an intelligent driving assistance system based on the Kanzi engine, characterized in that, include: Obtain obstacle perception data accessed through a standardized data interface, wherein the obstacle perception data includes the identification and status characteristics of obstacles; The obstacle perception data update status is detected in real time through a node attribute monitoring mechanism; In response to detected data updates, the obstacle perception data is parsed; within the preset rendering boundary, the corresponding visual prefab is dynamically scheduled for instantiation using an object pool mechanism. The properties of the visualization prefab are updated based on the parsed state features, and the dynamic rendering and display of the visualization prefab are executed by rewriting the rendering logic of the Kanzi engine.
2. The obstacle display method for an intelligent driving assistance system based on the Kanzi engine according to claim 1, characterized in that, The method of dynamically scheduling the corresponding visual prefab for instantiation using an object pool mechanism includes: Check if the obstacle's identifier exists in the active node table; If it does not exist, a visual prefab matching the obstacle type is retrieved from the backup node pool and reused; If the backup node pool is empty, the corresponding visual prefab template is loaded to instantiate a new visual prefab and added to the active node table.
3. The obstacle display method for an intelligent driving assistance system based on the Kanzi engine according to claim 1, characterized in that, Before updating the properties of the visualized prefab based on the parsed state features, the following steps are also included: Extract the first coordinates of the visualized prefab in the previous frame, and the second coordinates of the current frame obtained by parsing the obstacle perception data; Calculate the difference between the first coordinate and the second coordinate, and determine whether the difference exceeds a preset threshold; If the preset threshold is exceeded, a sudden change in position is determined, and a smooth transition is performed on the movement trajectory of the visualized prefab.
4. The obstacle display method for an intelligent driving assistance system based on the Kanzi engine according to claim 1, characterized in that, The parsing of the obstacle perception data includes: Read the mode attribute identifier to determine whether the current running mode is dynamic mode or static mode; Based on the determined operating mode, the obstacle perception data is bound to the corresponding hierarchical root node; According to the preset field extraction rules corresponding to the operating mode, the corresponding fields in the obstacle perception data are extracted.
5. The obstacle display method for an intelligent driving assistance system based on the Kanzi engine according to claim 4, characterized in that, The analysis process also includes a limit on the number of obstacles: The number of obstacles that have been resolved is counted in real time during the resolution process; When the number of targets being analyzed reaches the upper limit of the number of obstacles, the analysis of subsequent obstacle perception data is stopped; the analyzed target data is stored in the target data mapping table.
6. The obstacle display method for an intelligent driving assistance system based on the Kanzi engine according to claim 1, characterized in that, It also includes building 3D interactive scenes: Configure clickable properties and triggers for the instantiated visual prefab; In response to a touch-triggered event on the visual prefab, a message carrying the obstacle identifier is published; After the business logic layer subscribes to and receives the message, it obtains the detailed information of the obstacle and drives the information panel node to display the information.
7. An obstacle display device for an intelligent driving assistance system based on the Kanzi engine, characterized in that, include: The acquisition module is used to acquire obstacle perception data accessed through a standardized data interface, wherein the obstacle perception data includes the identification and status characteristics of obstacles; The detection module is used to detect the update status of the obstacle perception data in real time through a node attribute listening mechanism; The parsing module is used to parse the obstacle perception data in response to detected data updates; Within the preset rendering boundaries, the corresponding visual prefab is dynamically scheduled for instantiation using an object pool mechanism; The rendering module is used to update the properties of the visualization prefab based on the parsed state features, and to perform dynamic rendering and display of the visualization prefab by rewriting the rendering logic of the Kanzi engine.
8. The obstacle display device for an intelligent driving assistance system based on the Kanzi engine according to claim 7, characterized in that, The parsing module includes: The determination unit is used to read the mode attribute identifier and determine whether the current running mode is dynamic mode or static mode. The binding unit is used to bind the obstacle perception data to the corresponding hierarchical root node according to the determined operating mode; The extraction unit is used to extract the corresponding fields from the obstacle perception data according to the preset field extraction rules corresponding to the operating mode.
9. An electronic device, comprising: One or more processors; A storage device for storing one or more programs, which, when executed by one or more processors, cause the one or more processors to implement the obstacle display method for an intelligent driving assistance system based on the Kanzi engine as described in any one of claims 1 to 6.
10. A computer-readable medium having a computer program stored thereon, wherein, When the computer program is executed by the processor, it implements the obstacle display method for an intelligent driving assistance system based on the Kanzi engine as described in any one of claims 1 to 6.
