Automatic driving application visualization algorithm editing method, device and equipment

Abstract

The invention relates to the technical field of automatic driving application product development, and provides an automatic driving application visualization algorithm editing method and device, electronic equipment and a readable storage medium, and the method comprises the steps: obtaining first configuration data and second configuration data, the first configuration data comprises node configuration data, pile configuration data and connection configuration data, and the second configuration data comprises canvas configuration data and canvas arrangement data; based on a preset application program interface, the first configuration data is converted into a target component, and the target component is used for algorithm development or testing; converting the second configuration data into an initial canvas based on the application program interface; and rendering the initial canvas to obtain a visual canvas which supports loading and editing of the target component. According to the technical scheme provided by one or more embodiments of the invention, a plurality of functional personnel can be allowed to complete algorithm development and testing in parallel on a unified platform, and the information transmission delay and dependency relationship in a development link are reduced.

Description

Technical Field

[0001] The present disclosure relates to the technical field of autonomous driving application product development, and in particular to an autonomous driving application visualization algorithm editing method, device, electronic device, and readable storage medium. Background Art

[0002] At present, with the improvement of on-board chip computing power and the development of sensor technology, the automobile's autonomous driving technology has made significant progress. Autonomous driving technology can not only improve road safety and reduce traffic accidents, but also improve traffic efficiency and alleviate congestion problems, while providing drivers with a more comfortable and convenient driving experience. In addition, the development of autonomous driving technology will also promote the construction of intelligent transportation systems and smart cities, and have a positive impact on environmental protection and social and economic development.

[0003] The development and testing of autonomous driving applications is more complex than other software application products. It not only requires algorithm engineers to design and implement algorithm modules, but also system integrators to integrate modules, and test engineers to conduct rigorous testing and verification of algorithms. This process involves the integration of interdisciplinary knowledge, including vehicle technology, artificial intelligence, pattern recognition, wireless communications, sensor fusion, etc. In order to cope with ever-changing traffic scenarios, autonomous driving systems require massive amounts of data for algorithm training and cover more scenarios through continuous iterations. In addition, testing will run through the entire life cycle of the vehicle. Even if the vehicle is already on the road, it will be regularly upgraded remotely to adapt to new scenarios and needs.

[0004] With the rapid development of autonomous driving technology, the algorithm editing process of autonomous driving applications has been put forward with higher efficiency and flexibility requirements. However, the existing algorithm editors for autonomous driving applications have obvious limitations in supporting the collaborative work of multi-functional personnel, handling the dependencies between algorithm modules, verifying node data, and classifying management. Summary of the invention

[0005] In view of this, one or more embodiments of the present disclosure provide a method, device, electronic device and readable storage medium for visually editing algorithms for autonomous driving applications, which can allow multiple functional personnel to complete algorithm development and testing in parallel on a unified platform, thereby reducing information transmission delays and dependencies in the development chain.

[0006] On the one hand, the present disclosure provides a method for visually editing an algorithm for an autonomous driving application, the method comprising: obtaining first configuration data and second configuration data, the first configuration data comprising node configuration data, stub configuration data and connection configuration data, the second configuration data comprising canvas configuration data and canvas orchestration data; based on a preset application programming interface, converting the first configuration data into a target component, the target component being used for algorithm development or testing; based on the application programming interface, converting the second configuration data into an initial canvas; rendering the initial canvas to obtain a visual canvas, the visual canvas supporting loading and editing of the target component.

[0007] On the other hand, the present disclosure also provides a visual algorithm editing device for an autonomous driving application, the device comprising: a data receiving unit, used to obtain first configuration data and second configuration data, the first configuration data comprising node configuration data, pile configuration data and connection configuration data, the second configuration data comprising canvas configuration data and canvas orchestration data; a component generation unit, used to convert the first configuration data into a target component based on a preset application programming interface, the target component being used for algorithm development or testing; a canvas generation unit, used to convert the second configuration data into an initial canvas based on the application programming interface; a rendering unit, used to render the initial canvas to obtain a visual canvas, the visual canvas supporting the loading and editing of the target component.

[0008] On the other hand, the present disclosure further provides an electronic device, which includes a memory and a processor, wherein the memory is used to store a computer program, and when the computer program is executed by the processor, the above-mentioned method for visualizing an algorithm for editing an autonomous driving application is implemented.

[0009] On the other hand, the present disclosure further provides a computer-readable storage medium, which is used to store a computer program. When the computer program is executed by a processor, it implements the above-mentioned method for visualizing an algorithm for editing an autonomous driving application.

[0010] The technical solution provided by one or more embodiments of the present disclosure can convert relevant configuration data such as nodes, piles, and connections into corresponding target components through a preset application programming interface. At the same time, the configuration data of the canvas type can be converted into an initial canvas. The rendered initial canvas can be converted into a visual canvas and support the loading and editing of target components. In this way, multiple functional personnel can complete algorithm development and testing in parallel for different target components on a unified visualization platform, reducing information transmission delays and dependencies in the development chain.

[0011] The technical solutions provided by one or more embodiments of the present disclosure can improve the efficiency of collaborative development of autonomous driving application products and reduce the coupling between algorithm modules. This can not only accelerate the research and development process of some autonomous driving application products, but also promote the rapid iteration and innovation of autonomous driving application products while ensuring quality. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] The features and advantages of the embodiments of the present disclosure may be more clearly understood by referring to the accompanying drawings, which are schematic and should not be construed as limiting the present disclosure in any way. In the accompanying drawings:

[0013] Figure 1 A schematic diagram showing the steps of a method for editing a visual algorithm for an autonomous driving application in one embodiment of the present disclosure is shown;

[0014] Figure 2 A schematic diagram of the structure of a visual algorithm editing system for autonomous driving applications in one embodiment of the present disclosure is shown;

[0015] Figure 3 A schematic diagram of functional units of a visual algorithm editing device for autonomous driving applications in one embodiment of the present disclosure is shown;

[0016] Figure 4 A schematic structural diagram of an electronic device in one embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0017] In order to make the purpose, technical solutions and advantages of the embodiments of the present disclosure clearer, the technical solutions in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are part of the embodiments of the present disclosure, not all of the embodiments. Based on the embodiments of the present disclosure, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of the present disclosure.

[0018] In the related art, some algorithm editors for autonomous driving applications may have the following disadvantages: 1. The development and debugging links are too long. For example, in the process of algorithm development, a common autonomous driving application needs to go through multiple links from algorithm design to final integration and debugging, which leads to delayed information transmission, increases the development cycle and communication costs. 2. Strong dependencies between algorithm modules. For example, the development of different algorithm modules often requires data or functional support from other modules, which limits parallel development and affects the overall development efficiency. 3. Complex node data verification. For example, when processing the data required by different algorithm nodes, the algorithm editor must perform precise verification to ensure the correctness and applicability of the data, while the existing verification mechanism is usually fixed and not easy to adapt according to algorithm changes. 4. Classification management is difficult to customize. For example, the classification of existing algorithm component libraries is usually preset and fixed, and does not support users to customize type classification according to specific needs, which limits the flexible use and management of algorithm components. 5. Lack of component-level debugging capabilities. For example, due to the inability to customize component types and related classification management, developers cannot easily perform early debugging for specific components, thereby reducing the efficiency of the debugging process.

[0019] In view of this, in the field of autonomous driving application product development technology, there is an urgent need for an algorithm editing solution that can shorten the development chain, reduce dependencies between modules, provide a flexible verification mechanism and custom classification management.

[0020] See also Figure 1 , a method for visualizing an algorithm for editing an autonomous driving application provided by one embodiment of the present disclosure may include the following steps.

[0021] S1: Acquire first configuration data and second configuration data, wherein the first configuration data includes node configuration data, stub configuration data and connection configuration data, and the second configuration data includes canvas configuration data and canvas arrangement data.

[0022] In this embodiment, nodes and stubs correspond to two important roles in the software development process. Nodes are the basic units that constitute program logic, while stubs are tools used to simulate and control the test environment during the test process. Connections can represent data associations or data flows between different nodes and between nodes and stubs.

[0023] In this embodiment, the canvas can provide a drawing surface on which developers can draw text, lines, shapes, images, etc. After the canvas is rendered, a visual interface can be formed, which is convenient for users to modify and configure the elements therein. Specifically in this embodiment, different functional personnel can complete algorithm development and testing in parallel for different target components on a unified visual platform provided by the canvas.

[0024] In this embodiment, a node can refer to a specific location in the code or a specific operation unit, such as a variable, function, class, or statement. A node can implement functions such as acquiring data, storing data, performing specific operations, and controlling the flow of a program. A node can be a different algorithm module in an autonomous driving application.

[0025] In a practical application example, a node may be a perception module for object detection, thereby detecting objects around the vehicle, identifying pedestrians, other vehicles, traffic signals, etc. Furthermore, a node may be a semantic segmentation module in the perception module, for pixel-level classification of roads, vehicles, pedestrians, etc.; a node may be an instance segmentation module in the perception module, for distinguishing and identifying instances of each object in the image.

[0026] In an actual application example, a node may be a positioning and mapping module, which is used to determine the vehicle's location information. Furthermore, a node may be a positioning-inertial navigation fusion module in the positioning and mapping module, which is used to use global positioning system data and inertial measurement unit data to locate the vehicle; a node may be a lidar module in the positioning and mapping module, which is used to use lidar data for simultaneous positioning and mapping; a node may also be a vision module in the positioning and mapping module, which is used to use camera data for positioning and mapping.

[0027] In a practical application example, a node may be a path planning module for planning an autonomous driving route. Furthermore, a node may be a global path planning module in the path planning module for calculating the optimal path from the starting point to the end point based on map data; a node may be a local path planning module for planning a feasible path to avoid obstacles based on real-time perception data.

[0028] In a practical application example, a node may be a decision module, which is used to provide decision information. Furthermore, a node may be a behavior decision module in a decision module, which is used to determine the best behavior of the vehicle according to traffic rules, road conditions and the behavior of surrounding objects; a node may be a motion planning module in a decision module, which is used to determine the speed and direction of the vehicle to achieve smooth driving.

[0029] In a practical application example, the node can be a vehicle control module that controls the steering wheel, acceleration, and braking to achieve precise driving operations.

[0030] In a practical application example, a node can be a sensor fusion module that integrates data from multiple sensors, such as radar, lidar, cameras, etc., to obtain more accurate and reliable environmental information.

[0031] In a real-world application example, a node could be a prediction module that predicts the future positions and behaviors of other vehicles and pedestrians.

[0032] In a practical application example, the node can be a communication module for realizing vehicle-to-vehicle communication, vehicle-to-infrastructure communication such as traffic lights and roadside units, and vehicle-to-user mobile device communication.

[0033] In a real-world application example, a node could be a safety module for fault monitoring to ensure safe shutdown when a fault is detected.

[0034] In this embodiment, stubs are a software testing technique that can be used to simulate algorithm modules that have not yet been implemented or cannot be executed in a test environment. Stubs are often used for unit testing to isolate the code portion being tested and ensure that the focus of the test is only on a specific module. Stubs can replace the actual functional implementation of a node and provide a predetermined response, making the test more concise and efficient, and helping to detect and fix errors.

[0035] In an actual application example, stubs are used in the testing phase to simulate the modules called by the tested module. The stub module can simulate the functions of the lower-level modules and accept or pass the data of the tested module, making the unit test a relatively independent and simple process. In this way, for the algorithm node that needs to be tested, the associated stub of the node is tested instead, and the data or functional support of other nodes is no longer required, so that the development and testing of autonomous driving applications can be implemented in parallel, thereby improving the overall development efficiency of autonomous driving applications.

[0036] S2: Based on a preset application programming interface, convert the first configuration data into a target component, where the target component is used for algorithm development or testing.

[0037] In this embodiment, the node configuration data, the pile configuration data and the connection configuration data can be automatically converted into a target component via a preset application programming interface. Any target component can include a target node, an associated pile of the target node, and an associated connection of the target node. The preset application programming interface can pre-integrate some data structure management functions for the first configuration data.

[0038] In some embodiments, a data association relationship between the target components can be established according to the first configuration data. For example, different types of target components can be established according to different data types of node configuration data, pile configuration data, and line configuration data. On this basis, an association relationship between a node and a pile, and an association relationship between a node and a line can be established.

[0039] In some implementations, the file style of the target component may be determined based on the first configuration data. For example, the style of Cascading Style Sheets (CSS) may be modified to modify the shape, width, height, border width, text information, etc. of nodes, node-related piles, and node-related lines.

[0040] In some implementations, the callback event function of the target component may be determined based on the first configuration data. For example, the callback event function may be configured for nodes, node association piles, and node association lines, including configuring the event types allowed by nodes, node association piles, and node association lines, and the operations triggered by the current event type.

[0041] Based on the design of target components, a distributed development environment and modular algorithm component library for autonomous driving applications can be realized. This implementation allows multi-functional personnel to work on different target components in parallel, reducing the waiting time in the autonomous driving application development chain and accelerating the development cycle of the entire autonomous driving algorithm.

[0042] In some embodiments, the method for visualizing an algorithm for editing an autonomous driving application further includes: obtaining verification rules, the verification rules including a verification field name and a verification method, the verification method including a regular expression verification and a data type verification; obtaining scan data of the target component, and verifying the scan data based on the verification rules; if the scan data does not comply with the verification rules, outputting an error log, the error log including an error field location, an error field name, an expected data type, and an actual data type; if the scan data complies with the verification rules, rendering the target component corresponding to the scan data.

[0043] Specifically, the implementation entity of the visual algorithm editing method can provide a specific visual interface to allow users to add data verification rules in this interface. Each verification rule includes a custom verification field name and a verification method. The verification method can be selected based on regular expression verification or data type verification. If regular expression verification is selected, you need to enter a matching regular expression; if data type verification is selected, you need to select a data type, such as a numeric type, a string type, etc. After the user saves, the verification rules can be saved in the specified file storage area and can be saved in the project installation directory. When the user closes and reopens the visual interface, the implementation entity of the visual algorithm editing method can read the locally saved verification rule information file and restore the added verification rules.

[0044] After importing data, the implementation subject of the visual algorithm editing method can automatically obtain the locally saved verification rule information. Users can choose to enable the edited and saved verification rules according to the selection box of each verification rule. After enabling the verification rules, the implementation subject of the visual algorithm editing method can display the progress of importing data, and verify whether its data type meets the verification expectations one by one according to the field name index. For data components that pass the verification, the implementation subject of the visual algorithm editing method can output its component name through the success log. For data fields that do not meet expectations, the implementation subject of the visual algorithm editing method can output an error log, and the record content of the error log can include the error field location, error field name, expected data type and actual data type. After the data of all target components meet expectations, the implementation subject of the visual algorithm editing method can render the component library list.

[0045] Verification data can help users quickly check the correctness of data types and provide a basic way to verify data types. By importing the data verification phase, developers can save the lengthy final generation phase result correctness verification, thereby locating data errors more quickly. In particular, the dynamic data verification mechanism allows developers to configure verification rules according to actual needs, improving the accuracy of data processing and the robustness of the system.

[0046] S3: Based on the application programming interface, convert the second configuration data into an initial canvas.

[0047] In this embodiment, the canvas configuration data and the canvas arrangement data can be automatically converted into the initial canvas via a preset application programming interface. The preset application programming interface can pre-integrate some data structure management functions for the second configuration data.

[0048] In some embodiments, the basic properties of the initial canvas may be determined according to the canvas configuration data in the second configuration data. For example, some basic properties of the canvas may be modified, including canvas translation permission, background settings, grid settings, support for asynchronous rendering, support for node nesting, zoom ratio settings, node selection support, and enabling translation and zooming.

[0049] In some implementations, the extended tool applications of the initial canvas may be determined according to the canvas configuration data in the second configuration data. For example, some extended tool applications may be configured for the canvas, including enabling support for tools such as a mini-map, a clipboard, a drag tool, an operation history, a split line, and shortcut keys, as well as property settings for these tools.

[0050] In some implementations, the component support functions of the initial canvas may be determined according to the canvas configuration data in the second configuration data. For example, the node types, stub types, and connection types allowed to be displayed by the current canvas type may be set.

[0051] In some implementations, the hierarchical relationship between the initial canvases may be determined based on the canvas arrangement data in the second configuration data. For example, the canvas tree hierarchical relationship may be determined for each canvas type based on the parent canvas type in the configuration file, and if there is no parent canvas type, it represents a top-level canvas.

[0052] In some implementations, the hierarchical jump relationship between the initial canvases may be determined according to the canvas arrangement data in the second configuration data. For example, a jump mode for the current canvas type to enter a sub-canvas type may be set, and the jump mode may be a single-click, double-click operation, etc.

[0053] S4: Rendering the initial canvas to obtain a visible canvas, wherein the visible canvas supports loading and editing of the target component.

[0054] In this embodiment, after the canvas is rendered, a visual interface can be formed, thereby facilitating the user to modify and configure the elements (target components) therein.

[0055] In some embodiments, the method for visualizing an algorithm for editing an autonomous driving application further includes: receiving a classification editing instruction from a user, wherein the classification editing instruction includes a creation instruction, a modification instruction, and a deletion instruction; and classifying and managing the target component according to the classification editing instruction.

[0056] Specifically, custom classification management is designed to allow users to freely create, modify, and delete classifications of algorithm components as needed, making it easier to locate and modify imported data. Through classification management, users can operate with an intuitive graphical interface.

[0057] In the component library, users can modify or delete the categories of any component library. Specifically, when right-clicking on a component library category, users can choose to delete the category, modify the category name, or add a new component library category type in the right-click menu. When the user modifies a category, the component type properties of all target components under that type will also be modified accordingly to ensure that the component type matches the category. After adding a new component category, the implementation body of the visualization algorithm editing method can re-render the component library list and display the component type names that match the category name under that category.

[0058] Through the custom category management interface, users can intuitively and freely create, modify and delete categories of algorithm components, thereby realizing custom category management and improving component organization efficiency and search speed.

[0059] In some embodiments, the method for visually editing an algorithm for an autonomous driving application further includes at least one of the following steps: in response to a first operation instruction from a user, loading the target component into the visual canvas; in response to a second operation instruction from a user, modifying component parameters of a current component in the visual canvas; and in response to a third operation instruction from a user, creating a custom component.

[0060] In a practical application example, the target component in the component library has passed the data validation rules and has been rendered. Each entry can represent a component name entry that matches the component type under the category, and the entry can be dragged to the canvas to form a node topology. Users can add, delete, and modify field entries for node parameters through the right-click menu.

[0061] In an actual application example, a custom component that is unrelated to the first configuration data can be generated in the component library list. After determining the component type of the custom component, the custom component can be completed by user-defined fields and specific values; or the user can specify the data type of the field and value and fill in random values ​​to complete it. After the custom component is saved, it can be merged with the imported system data and stored in a local file without contaminating the original imported data (such as the first configuration data and the second configuration data). For custom components, special fields such as "isCustom" can be added for identification and distinction.

[0062] By generating built-in preset components and custom components, developers can debug specific components in advance, speeding up the process of error troubleshooting and function verification.

[0063] In some embodiments, the method for visually editing an algorithm for an autonomous driving application further includes: obtaining an interface configuration instruction including an interface address and interface parameters; generating a file calling interface according to the interface configuration instruction, wherein the file calling interface is used to output an algorithm file, and the algorithm file is generated based on the target component and the visual canvas.

[0064] This ensures that newly developed algorithm components and classifications can be easily imported into the front-end code and seamlessly integrated with existing projects.

[0065] Specifically, the visual algorithm editing method for autonomous driving applications can integrate the entire process from algorithm data to scan data and scan data to generated files. Users can add custom configuration information, including the field name and corresponding value of the configuration information. After completing the interface configuration, the user clicks Save, and the current configuration will be saved locally in the form of a file according to the input scheme name.

[0066] In an actual application example, the user can fill in the configuration information scheme required to request the target container (Docker) through the configuration function provided by the system. After the user requests the Docker operation, he can select the corresponding request scheme. The system will send the request to the corresponding address based on the user's configuration information. The process from binary data file to scanned data, or from scanned data to generated compiled files is successfully executed.

[0067] See also Figure 2 , an embodiment of the present disclosure provides a visual algorithm editing system for autonomous driving applications, which is mainly divided into three modules, namely, a configuration file, a conversion application programming interface, and a debugging engine.

[0068] According to the configuration data generated by the modeling engine, the configuration information of nodes, piles, and connections can be converted into the basic style display, data mapping relationship, trigger events, etc. of the current canvas type through the conversion application programming interface. At the same time, the conversion application programming interface can convert the configuration information of the canvas type into basic property settings such as canvas background, zoom, grid, etc., as well as custom events and tool support. The system is applied on Docker, which can be manifested as canvas rendering, registration of listening events, loading of provided data, and callback of custom components.

[0069] The functions supported by the debugging engine may include component library classification management, component type management, preset component management, tool management and model simulation (mock).

[0070] The main usage process of the debugging engine is as follows:

[0071] First, add the validation rules to determine the field name to be validated and the field data type to be validated for the field. Then import the provided scan data, or generate scan data from the algorithm binary file after configuring the request Docker information to perform rule validation. If the rule validation is not met, the specific error location log is output. After successfully passing the validation, the component library list corresponding to the data can be rendered.

[0072] After that, you can drag and drop the nodes supported by the current canvas type in the component library onto the canvas. In the component library, you can mock or customize the corresponding values ​​of the specified fields to complete the custom component operation. You can manually classify the nodes in the component library through the classification configuration menu. For the nodes dragged to the canvas, you can view the configuration information of the current node through the parameter configuration menu and manually modify the node parameters. In addition, you can also manually configure the generated interface address and the corresponding interface parameters. Users can verify the correctness of the imported data by verifying the generated interface results.

[0073] The visual algorithm editing system for autonomous driving applications provided in this embodiment can simplify the code integration process. The front-end code integration interface simplifies the integration process of new algorithm components through automated scripts and tool chains, reducing the error rate and time cost of manual operations.

[0074] The visual algorithm editing system for autonomous driving applications provided in this embodiment can improve the debugging efficiency of autonomous driving applications. The integrated pre-built component and custom component debugging tools provide comprehensive debugging support, including interfaces with domain controllers, making problem location and repair more efficient.

[0075] The autonomous driving application visual algorithm editing system provided in this embodiment can quickly iterate autonomous driving applications. Due to the modularity and flexibility of the system, it can support the rapid iterative development of autonomous driving applications, which helps to quickly verify new ideas and deploy them into new versions of autonomous driving applications.

[0076] The visual algorithm editing system for autonomous driving applications provided in this embodiment has compatibility and maintainability. Standardized design and clear integration specifications ensure that autonomous driving applications are easy to maintain, while improving adaptability to new technologies and future needs.

[0077] The technical solution provided by one or more embodiments of the present disclosure can convert relevant configuration data such as nodes, piles, and connections into corresponding target components through a preset application programming interface. At the same time, the configuration data of the canvas type can be converted into an initial canvas. The rendered initial canvas can be converted into a visual canvas and support the loading and editing of target components. In this way, multiple functional personnel can complete algorithm development and testing in parallel for different target components on a unified visualization platform, reducing information transmission delays and dependencies in the development chain.

[0078] The technical solutions provided by one or more embodiments of the present disclosure can improve the efficiency of collaborative development of autonomous driving applications and reduce the coupling between algorithm modules. This can not only accelerate the research and development process of some autonomous driving applications, but also promote the rapid iteration and innovation of autonomous driving applications while ensuring quality.

[0079] See also Figure 3 The present disclosure also provides a visual algorithm editing device for autonomous driving applications, the device comprising:

[0080] The data receiving unit 100 is used to obtain first configuration data and second configuration data, wherein the first configuration data includes node configuration data, stub configuration data and connection configuration data, and the second configuration data includes canvas configuration data and canvas arrangement data;

[0081] A component generation unit 200, configured to convert the first configuration data into a target component based on a preset application programming interface, wherein the target component is used for algorithm development or testing;

[0082] A canvas generation unit 300, configured to convert the second configuration data into an initial canvas based on the application programming interface;

[0083] The rendering unit 400 is used to render the initial canvas to obtain a visible canvas, and the visible canvas supports loading and editing of the target component.

[0084] In one embodiment, the device also includes a data verification unit 500, which is used to obtain verification rules, the verification rules include a verification field name and a verification method, the verification method includes a regular expression verification and a data type verification; obtain the scan data of the target component, and verify the scan data based on the verification rules; if the scan data does not comply with the verification rules, output an error log, the error log includes the error field position, the error field name, the expected data type and the actual data type; if the scan data complies with the verification rules, render the target component corresponding to the scan data.

[0085] In one embodiment, the component generation unit 200 is specifically used to establish a data association relationship between the target components based on the first configuration data; determine the file style of the target component based on the first configuration data; and determine the callback event function of the target component based on the first configuration data.

[0086] In one embodiment, the canvas generation unit 300 is specifically used to determine the basic canvas properties of the initial canvas according to the canvas configuration data in the second configuration data; determine the expansion tool application of the initial canvas according to the canvas configuration data in the second configuration data; determine the component support function of the initial canvas according to the canvas configuration data in the second configuration data.

[0087] In one embodiment, the canvas generation unit 300 is specifically configured to determine the hierarchical relationship between the initial canvases according to the canvas arrangement data in the second configuration data; and determine the hierarchical jump relationship between the initial canvases according to the canvas arrangement data in the second configuration data.

[0088] In one embodiment, the device further includes a category management unit 600 for receiving a category editing instruction from a user, wherein the category editing instruction includes a creation instruction, a modification instruction, and a deletion instruction; and classifying and managing the target component according to the category editing instruction.

[0089] In one embodiment, the device also includes a component management unit 700, which is used to load the target component into the visual canvas in response to a first operation instruction from a user; modify the component parameters of the current component in the visual canvas in response to a second operation instruction from a user; and create a custom component in response to a third operation instruction from a user.

[0090] In one embodiment, the device also includes an interface generation unit 800, which is used to obtain an interface configuration instruction including an interface address and interface parameters; based on the interface configuration instruction, a file calling interface is generated, and the file calling interface is used to output an algorithm file, and the algorithm file is generated based on the target component and the visual canvas.

[0091] Each unit described in the above embodiments may be implemented by a computer chip or a product having a certain function. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0092] For the convenience of description, the above devices are described in terms of functions and are described separately in various units. Of course, when implementing the present application, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0093] See also Figure 4 The present disclosure also provides an electronic device, which includes a memory and a processor, wherein the memory is used to store a computer program, and when the computer program is executed by the processor, the above-mentioned method for visualizing the algorithm for editing an autonomous driving application is implemented.

[0094] The present disclosure also provides a computer-readable storage medium, which is used to store a computer program. When the computer program is executed by a processor, it implements the above-mentioned method for visualizing an algorithm for editing an autonomous driving application.

[0095] The processor may be a central processing unit (CPU). The processor may also be other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, or a combination of the above chips.

[0096] As a non-transitory computer-readable storage medium, the memory can be used to store non-transitory software programs, non-transitory computer executable programs and modules, such as program instructions / modules corresponding to the method in the embodiment of the present disclosure. The processor executes various functional applications and data processing of the processor by running the non-transitory software programs, instructions and modules stored in the memory, that is, implementing the method in the above method embodiment.

[0097] The memory may include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application required for at least one function; the data storage area may store data created by the processor, etc. In addition, the memory may include a high-speed random access memory, and may also include a non-transitory memory, such as at least one disk storage device, a flash memory device, or other non-transitory solid-state storage device. In some embodiments, the memory may optionally include a memory remotely disposed relative to the processor, and these remote memories may be connected to the processor via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0098] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiments can be implemented by instructing the relevant hardware through a computer program, and the program can be stored in a computer-readable storage medium, and when the program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, the storage medium can be a disk, an optical disk, a read-only memory (ROM), a random access memory (RAM), a flash memory, a hard disk drive (HDD) or a solid-state drive (SSD), etc.; the storage medium can also include a combination of the above-mentioned types of memory.

[0099] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the embodiments of the device, equipment, and storage medium, since they are basically similar to the method embodiments, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiments.

[0100] The above is only an embodiment of the present application and is not intended to limit the present application. For those skilled in the art, the present application may have various changes and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.

[0101] Although the embodiments of the present disclosure have been described in conjunction with the accompanying drawings, those skilled in the art may make various modifications and variations without departing from the spirit and scope of the present disclosure, and such modifications and variations are all within the scope defined by the appended claims.

Claims

1. A method for visualizing an algorithm for editing an autonomous driving application, characterized in that: The method comprises: Acquire first configuration data and second configuration data, the first configuration data including node configuration data, stub configuration data and connection configuration data, and the second configuration data including canvas configuration data and canvas arrangement data; Based on a preset application programming interface, converting the first configuration data into a target component, wherein the target component is used for algorithm development or testing; Based on the application programming interface, converting the second configuration data into an initial canvas; The initial canvas is rendered to obtain a visual canvas, and the visual canvas supports loading and editing of the target component.

2. The method according to claim 1, characterized in that The method further comprises: Obtain verification rules, the verification rules including verification field name and verification method, the verification method including regular expression verification and data type verification; Acquire scan data of the target component, and verify the scan data based on the verification rule; If the scanned data does not conform to the verification rule, an error log is output, wherein the error log includes an error field position, an error field name, an expected data type, and an actual data type; If the scan data meets the verification rule, the target component corresponding to the scan data is rendered.

3. The method according to claim 1, characterized in that The converting the first configuration data into a component includes at least one of the following: According to the first configuration data, establishing a data association relationship between the target components; Determining a file style of the target component according to the first configuration data; A callback event function of the target component is determined according to the first configuration data.

4. The method according to claim 1, characterized in that: The converting the second configuration data into an initial canvas includes at least one of the following: Determining basic canvas properties of the initial canvas according to the second configuration data; Determining an expansion tool application of the initial canvas according to the second configuration data; Determining component support functions of the initial canvas according to the second configuration data; Determining a hierarchical relationship between the initial canvases according to the second configuration data; According to the second configuration data, a hierarchical jump relationship between the initial canvases is determined.

5. The method according to claim 1 or 2, characterized in that: The method further comprises: Receiving a category editing instruction from a user, wherein the category editing instruction includes a create instruction, a modify instruction, and a delete instruction; According to the classification editing instruction, the target component is classified and managed.

6. The method according to claim 1 or 2, characterized in that: The method further comprises at least one of the following: In response to a first operation instruction of a user, loading the target component into the visual canvas; In response to a second operation instruction of the user, modifying a component parameter of a current component in the visual canvas; In response to a third operation instruction from the user, a custom component is created.

7. The method according to claim 1 or 2, characterized in that: The method further comprises: Get the interface configuration instruction including the interface address and interface parameters; According to the interface configuration instruction, a file calling interface is generated, and the file calling interface is used to output an algorithm file, and the algorithm file is generated based on the target component and the visual canvas.

8. A visual algorithm editing device for autonomous driving applications, characterized in that: The device comprises: A data receiving unit, configured to obtain first configuration data and second configuration data, wherein the first configuration data includes node configuration data, stub configuration data and connection configuration data, and the second configuration data includes canvas configuration data and canvas arrangement data; A component generation unit, configured to convert the first configuration data into a target component based on a preset application programming interface, wherein the target component is used for algorithm development or testing; A canvas generating unit, configured to convert the second configuration data into an initial canvas based on the application programming interface; The rendering unit is used to render the initial canvas to obtain a visual canvas, and the visual canvas supports loading and editing of the target component.

9. An electronic device, characterized in that: The electronic device comprises a memory and a processor, wherein the memory is used to store a computer program, and when the computer program is executed by the processor, the method according to any one of claims 1 to 7 is implemented.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium is used to store a computer program, and when the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.

Images