Rendering Method, Device and Storage Medium Based on AI Algorithm of YTS System

Abstract

The present application provides a rendering method, device and storage medium based on the AI algorithm of the YTS system, relating to the technical field of image rendering, and solving the technical problem of low GPU operation efficiency in the process of image rendering. The method includes: obtaining original image data to be processed; analyzing the original image data by a first GPU using an AI algorithm and performing object recognition on the original image data to obtain a plurality of objects to be rendered in the original image data; based on the plurality of objects to be rendered, using a 3D engine by the first GPU to distributively establish an initial object model corresponding to each object to be rendered; according to the original image data, using a second GPU to perform multi-dimensional adjustment on the initial object model in combination with specified scene requirement data to obtain an adjusted target object model; and performing image rendering on the target object model by the second GPU to obtain an image rendering result corresponding to the original image data under the specified scene requirement data.

Description

Technical Field

[0001] This application relates to the field of image rendering technology, and in particular, to a rendering method, device, and storage medium based on the AI algorithm of the YTS system. Background Art

[0002] Image rendering is the process of converting three-dimensional light energy transfer processing into a two-dimensional image. Scenes and entities are represented in three-dimensional form, which is closer to the real world and convenient for manipulation and transformation, while most graphic display devices are two-dimensional rasterized displays and dot matrix printers. The representation from a three-dimensional entity scene to a two-dimensional raster and dot matrix is image rendering - that is, rasterization. A raster display can be regarded as a pixel matrix, and any graphic displayed on the raster display is actually a collection of pixels with one or more colors and grayscales.

[0003] A Graphics Processing Unit (GPU), also known as a display core, display chip, or video processor, is a coprocessor used to process image and graphics operations, providing relatively realistic rendering effects in its application fields such as image processing. However, the current performance of the GPU is low, resulting in a low operating efficiency of the GPU in the existing image rendering process. Summary of the Invention

[0004] The purpose of the present invention is to provide a rendering method, device, and storage medium based on the AI algorithm of the YTS system to solve the technical problem of low operating efficiency of the GPU in the image rendering process.

[0005] In a first aspect, this application provides a Unity image rendering method based on the Artificial Intelligence (AI) algorithm of the YTS system, which is applied to a Graphics Processing Unit (GPU) device. The GPU device includes a first GPU and a second GPU. The method includes:

[0006] Obtain the original image data to be processed;

[0007] Use the first GPU to analyze the original image data with the AI algorithm and perform object recognition on the original image data to obtain multiple objects to be rendered in the original image data;

[0008] Based on the multiple objects to be rendered, use the first GPU to distributively establish an initial object model corresponding to each object to be rendered through a 3D engine;

[0009] Based on the original image data, the second GPU combines the specified scenario requirement data to perform multi-dimensional adjustment on the initial object model, obtaining an adjusted target object model; wherein, the specified scenario requirement data includes at least one of intelligent vehicle-mounted scenario requirement data, autonomous driving scenario requirement data, vehicle-road connection scenario requirement data, vehicle-vehicle connection scenario requirement data, vehicle-person connection scenario requirement data, and vehicle-person-road connection scenario requirement data; the adjustment dimensions of the multi-dimensional adjustment include at least one of light source angle, brightness, color, and contrast;

[0010] Based on the target object model, the second GPU performs image rendering to obtain an image rendering result corresponding to the original image data under the specified scenario requirement data.

[0011] In a possible implementation, the GPU device further includes a third GPU; after analyzing the original image data using an AI algorithm through the first GPU, an original image analysis result is obtained; the performing image rendering based on the target object model through the second GPU to obtain an image rendering result corresponding to the original image data under the specified scenario requirement data includes:

[0012] The third GPU performs image rendering on the target object model according to the specified low-pixel requirement data to obtain an initial image rendering result;

[0013] The second GPU reads the original image analysis result and performs a refined adjustment process on the initial image rendering result according to the original image analysis result according to the specified high-pixel requirement data to adjust the pixel increase of the initial image rendering result, obtaining a final image rendering result; wherein, the pixels corresponding to the specified high-pixel requirement data are higher than those corresponding to the specified low-pixel requirement data.

[0014] In a possible implementation, the GPU device is disposed in a vehicle-mounted device, and the vehicle-mounted device corresponds to a vehicle-mounted user; the second GPU reads the original image analysis result and performs a refined adjustment process on the initial image rendering result according to the original image analysis result according to the specified high-pixel requirement data to adjust the pixel increase of the initial image rendering result, obtaining a final image rendering result, including:

[0015] Obtain a user operation for the vehicle-mounted device, and analyze the composition aesthetic preference data corresponding to the vehicle-mounted user through an AI system according to the user operation;

[0016] The second GPU reads the composition aesthetic preference data and performs composition adjustment processing on the initial image rendering result according to the composition aesthetic preference data, so as to adjust the composition style of the initial image rendering result to conform to the composition aesthetic preference data, and obtain the first image rendering result;

[0017] The second GPU reads the original image analysis result, and performs fine adjustment processing on the first image rendering result according to the original image analysis result and the specified high-pixel requirement data, so as to increase the pixels of the first image rendering result, and obtain the final second image rendering result.

[0018] In a possible implementation, the multiple objects to be rendered include any one or more of the following:

[0019] Vehicles, buildings, trees, and people.

[0020] In a possible implementation, a Unity engine is set in the second GPU; the image rendering of the target object model through the second GPU to obtain the image rendering result corresponding to the original image data under the specified scene requirement data includes:

[0021] Accelerate the second GPU through the ShaderGraph and ComputeShader of the Unity engine, and pre-calculate multiple target matrices in the target object model based on the target object model by using the ScriptingDefineSymbols and CustomEditor of the Unity engine;

[0022] Perform distributed calculation on the multiple target matrices by using the NetworkManager and MultiplayerAPI of the Unity engine based on the multiple target matrices to obtain a distributed calculation result, and perform image rendering on the target object model through the accelerated second GPU based on the distributed calculation result to obtain the image rendering result corresponding to the original image data under the specified scene requirement data.

[0023] In a possible implementation, the accelerating the second GPU through the ShaderGraph and ComputeShader of the Unity engine includes:

[0024] Dynamically allocate the resources of the second GPU through the following formula: GPUResources(x) = γ(x) × ObjectImportance(x), where γ(x) is the weight varying with position, and ObjectImportance(x) is the importance of the object at position x;

[0025] Adjust the task priority of the second GPU through the following formula: GPUPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x), where δ(t) and ε(t) are the weights varying with time, TaskImportance(t, x) is the importance varying with time at position x, and TaskUrgency(t, x) is the task priority varying with time at position x.

[0026] In a possible implementation, pre-compute multiple target matrices in the target object model by using ScriptingDefineSymbols and CustomEditor of the Unity engine based on the target object model, including:

[0027] Determine the pre-compute frequency through the following formula according to the specified parameters varying with time: PreconputeFrequency(t) = α(t) × SceneChangeRate(t) + β(t), where α(t) and β(t) are the specified parameters varying with time;

[0028] Pre-compute multiple target matrices in the target object model by using ScriptingDefineSymbols and CustomEditor of the Unity engine based on the target object model at the pre-compute frequency through the following formula:

[0029] PrecomputePriority(x) = γ(x) × ObjectImportance(x), where γ(x) is the weight varying with position of the target object model, and ObjectImportance(x) is the importance of the target object model at position x;

[0030] PrecomputeTaskPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x), where δ(t) and ε(t) are time-varying weights, TaskImportance(t, x) is the importance of the target object model varying with time at position x, and TaskUrgency(t, x) is the task priority of the target object model varying with time at position x.

[0031] In a possible implementation, the distributed computing of the multiple target matrices is performed using the NetworkManager and MultiplayerAPI of the Unity engine based on the multiple target matrices, and the distributed computing result is obtained, including:

[0032] The dynamic adjustment task assignment policy is determined by the following formula: TaskAssignment(t) = arg max(NetworkQuality_i(t) × TaskPriority_i(t)), where NetworkQuality_i(t) is the network quality of the i-th node at time point t, and TaskPriority_i(t) is the priority of the i-th task at time point t;

[0033] The computing resources are dynamically allocated by the following formula: ComputeResources(x) = γ(x) × TaskDemand(x), where γ(x) is a weight varying with position, and TaskDemand(x) is the demand of the task at position x;

[0034] The task assignment priority is adjusted by the following formula: TaskPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x), where δ(t) and ε(t) are time-varying weights, TaskImportance(t, x) is the importance of the target matrix varying with time at position x, and TaskUrgency(t, x) is the task priority of the target matrix varying with time at position x;

[0035] Based on the multiple target matrices, the distributed computing of the multiple target matrices is performed according to the task assignment priority through the dynamic adjustment task assignment policy using the computing resources dynamically allocated in the Unity engine, and the distributed computing result is obtained.

[0036] Second aspect, the present application provides a Unity image rendering device based on the AI algorithm of the YTS system, which is applied to a GPU device. The GPU device includes a first GPU and a second GPU. The device includes:

[0037] An acquisition module, configured to acquire the original image data to be processed;

[0038] An identification module, configured to analyze the original image data by using the AI algorithm through the first GPU and perform object identification on the original image data to obtain a plurality of objects to be rendered in the original image data;

[0039] A building module, configured to distributively build an initial object model corresponding to each object to be rendered by using a 3D engine through the first GPU based on the plurality of objects to be rendered;

[0040] An adjustment module, configured to perform multi-dimensional adjustment on the initial object model by using the second GPU in combination with specified scene requirement data according to the original image data to obtain an adjusted target object model; wherein, the specified scene requirement data includes at least one of intelligent vehicle-mounted scene requirement data, autonomous driving scene requirement data, vehicle-road connection scene requirement data, vehicle-vehicle connection scene requirement data, vehicle-person connection scene requirement data, and vehicle-person-road connection scene requirement data; the adjustment dimensions of the multi-dimensional adjustment include at least one of light source angle, brightness, color, and contrast;

[0041] A rendering module, configured to perform image rendering through the second GPU based on the target object model to obtain an image rendering result corresponding to the original image data under the specified scene requirement data.

[0042] Third aspect, the present application further provides an electronic device, including a memory and a processor. A computer program that can run on the processor is stored in the memory. When the processor executes the computer program, the method described in the first aspect above is implemented.

[0043] Fourth aspect, the present application further provides a computer-readable storage medium. The computer-readable storage medium stores computer-executable instructions. When the computer-executable instructions are called and run by the processor, the computer-executable instructions cause the processor to run the method described in the first aspect above.

[0044] The present application brings the following beneficial effects:

[0045] A rendering method, device, and storage medium based on the AI algorithm of the YTS system provided by this application can obtain the original image data to be processed, analyze the original image data using the AI algorithm by the first GPU, and perform object recognition on the original image data to obtain multiple objects to be rendered in the original image data. Based on the multiple objects to be rendered, the first GPU uses the 3D engine to distributively establish an initial object model corresponding to each object to be rendered. According to the original image data, the second GPU combines the specified scene requirement data to perform multi-dimensional adjustment on the initial object model to obtain the adjusted target object model. Among them, the specified scene requirement data includes at least one of intelligent vehicle-mounted scene requirement data, autonomous driving scene requirement data, vehicle-road connection scene requirement data, vehicle-vehicle connection scene requirement data, vehicle-person connection scene requirement data, and vehicle-person-road connection scene requirement data. The adjustment dimensions of the multi-dimensional adjustment include at least one of light source angle, brightness, color, and contrast. Based on the target object model, the second GPU performs image rendering to obtain the image rendering result corresponding to the original image data under the specified scene requirement data. In this solution, by allocating work to two independent GPUs (the first GPU and the second GPU), computing-intensive tasks such as object recognition and model establishment can be carried out simultaneously with scene adjustment and final rendering. This reduces the load on a single GPU and makes full use of the advantages of multi-cores in modern GPU architectures. The first GPU is responsible for analyzing the original image data and establishing the initial object model, which is a relatively complex but one-time process; while the second GPU focuses on optimizing and rendering these models according to specific scene requirements. Such a division of labor allows each GPU to concentrate on the most suitable task, realizing intelligent task allocation and improving the overall work efficiency. Moreover, considering the specific requirements of different application scenarios (such as intelligent vehicle-mounted, autonomous driving, etc.), this method allows customized parameter adjustment for each case. This means that in practical applications, the rendering effect is more in line with expectations, reducing unnecessary computational overhead. For example, in some cases, a very high level of detail or complex lighting effects are not required, achieving rendering optimization for specific scenarios. Also, the multi-dimensional adjustment in aspects such as light source angle, brightness, color, and contrast is performed after modeling, rather than directly acting on the original image data. This method avoids repeated processing of the same image information because once the object model is established, its attributes can be modified more effectively without having to re-parse the entire scene. In addition, by using the AI algorithm for object recognition and feature extraction, it is possible to better understand the input data, thereby generating a more compact and efficient 3D model. This not only helps reduce the demand for storage space, efficiently utilize hardware resources, but also reduces the amount of data in the subsequent processing stage, thereby enhancing the working efficiency of the GPU.Furthermore, the first GPU uses the 3D engine to distributively establish the initial object model corresponding to each object to be rendered. This approach can accelerate the model establishment process. Especially when dealing with a large number of complex objects, distributed computing can significantly shorten the time. In summary, through reasonable task flow planning, effective utilization of hardware resources, and targeted adaptation to the requirements of different application scenarios, this method effectively improves the operating efficiency of the GPU.

[0046] To make the above objects, features, and advantages of the present application more obvious and understandable, the following specifically gives preferred embodiments and, in conjunction with the accompanying drawings, provides a detailed description as follows. Brief Description of the Drawings

[0047] To more clearly illustrate the specific embodiments of the present application or the technical solutions in the prior art, the following will briefly introduce the drawings required for use in the description of the specific embodiments or the prior art. Obviously, the drawings in the following description are some embodiments of the present application. For those of ordinary skill in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0048] Figure 1 Schematic flowchart of the Unity image rendering method based on the AI algorithm of the YTS system provided by the embodiment of the present application;

[0049] Figure 2 Another schematic flowchart of the Unity image rendering method based on the AI algorithm of the YTS system provided by the embodiment of the present application;

[0050] Figure 3 Schematic structural diagram of a Unity image rendering device based on the AI algorithm of the YTS system provided by the embodiment of the present application;

[0051] Figure 4 Shows the schematic structural diagram of an electronic device provided by the embodiment of the present application. Detailed Embodiments

[0052] To make the objectives, technical solutions, and advantages of the embodiments of the present application clearer, the following will clearly and completely describe the technical solutions of the present application in conjunction with the drawings. Obviously, the described embodiments are some, but not all, of the embodiments of the present application. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative efforts fall within the scope of protection of the present application.

[0053] As used in the embodiments of the present application, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally further include other steps or units not listed, or may optionally further include other steps or units inherent to these processes, methods, products, or devices.

[0054] Currently, the GPU running efficiency in the image rendering process is relatively low. Based on this, the embodiments of the present application provide a rendering method, device, and storage medium based on the YTS system AI algorithm, which can solve the technical problem of low GPU running efficiency in the image rendering process.

[0055] The embodiments of the present invention will be further introduced below with reference to the accompanying drawings.

[0056] Figure 1 It is a schematic flowchart of a Unity image rendering method based on the YTS system AI algorithm provided by the embodiments of the present application. Among them, this method is applied to a GPU device, and the GPU device includes a first GPU and a second GPU. As Figure 1 shown, this method includes:

[0057] Step S110, obtain the original image data to be processed.

[0058] In the embodiments of the present application, at least one GPU (GPU distribution) is used in the image rendering process: the first GPU is used for AI operations; the second GPU is used for rendering images. Obtain the original image data (picture or video) to be rendered.

[0059] In some cases, it may be necessary to perform preliminary processing on the original image. For example, adjust the image size, convert the color mode, remove noise, annotate key information in the image, etc. to ensure its suitability for subsequent processing or analysis. Then, organize and store the collected image data according to certain rules to ensure easy access and management. After that, check the quality of the image data to ensure that it meets the expected standards. This step may include deleting damaged files and filtering out irrelevant or low-quality images.

[0060] In practical applications, the YTS (unity TV Service) system in the embodiments of this application represents a unity visual rendering service system. Among them, unity is a real-time 3D interactive content creation and operation platform. All creators, including game development, art, architecture, automotive design, and film and television, can turn their creativity into reality with the help of unity. The platform provides a complete set of software solutions that can be used to create, operate, and monetize any real-time interactive 2D and 3D content. The supported platforms include mobile phones, tablets, PCs, game consoles, augmented reality, and virtual reality devices.

[0061] Step S120: Analyze the original image data using an AI algorithm through the first GPU and perform object recognition on the original image data to obtain multiple objects to be rendered in the original image data.

[0062] As an optional implementation manner, the multiple objects to be rendered include any one or more of the following: vehicles, buildings, trees, and people. The first GPU analyzes the original image data and identifies multiple objects to be rendered (such as vehicles, buildings, trees, people, items, etc.) in the original image data.

[0063] Exemplarily, first select a pre-trained model, that is, select a suitable object recognition pre-trained model according to the task requirements, such as YOLO, Faster R-CNN, SSD, etc. Customize the model (if necessary): In some cases, it may be necessary to fine-tune the existing model or completely build a new model from scratch to meet specific requirements. Load the model: Load the selected model into memory and transfer it to the GPU for running. Then, send the preprocessed image data into the model for object recognition. This process includes but is not limited to feature extraction, classification, bounding box prediction, etc. For the results output by the model, further post-processing may be required, such as non-maximum suppression (NMS) to filter the final detection boxes and remove redundant detection results. Then, parse the information of each recognized object from the output of the model, such as category, confidence score, position coordinates, etc. Generate a list of objects to be rendered: Based on the parsing results, create an entry for each recognized object, containing all necessary information for subsequent rendering.

[0064] Step S130: Based on the multiple objects to be rendered, use the first GPU to distributively establish an initial object model corresponding to each object to be rendered through a 3D engine.

[0065] In this step, the first GPU first randomly and distributively establishes initial object models corresponding to the multiple objects to be rendered for each image to be rendered. At this time, it has not been rendered yet.

[0066] Specifically, first, according to the results of object recognition, the data of the object to be rendered is reasonably segmented to ensure that each GPU node only processes a part of the data. Data transmission: Through a network or shared storage mechanism, the segmented data is efficiently transmitted to each GPU node. Load balancing: Use resource management and scheduling tools (such as Horovod in Kubernetes, NVIDIA's multi-instance GPU technology, etc.) to ensure load balancing among GPU nodes. Dynamic resource allocation: Dynamically adjust the GPU resources allocated to each node according to real-time task requirements to improve resource utilization.

[0067] For the establishment of the initial object model, 3D modeling engine integration: Select a suitable 3D modeling engine (such as Unity, Unreal Engine, Blender, etc.) and integrate it with the distributed computing framework. Parallelize the modeling process: For each object to be rendered, start a 3D engine instance on the corresponding GPU node and simultaneously start building the initial model of the object. Parameter optimization: Set the optimal parameter configuration for each 3D engine instance to ensure modeling speed and quality.

[0068] In step S140, according to the original image data, the initial object model is multi-dimensionally adjusted by the second GPU in combination with the specified scene requirement data to obtain the adjusted target object model.

[0069] Among them, the specified scene requirement data includes at least one of intelligent vehicle-mounted scene requirement data, autonomous driving scene requirement data, vehicle-road connection scene requirement data, vehicle-vehicle connection scene requirement data, vehicle-person connection scene requirement data, and vehicle-person-road connection scene requirement data; the adjustment dimensions of the multi-dimensional adjustment include at least one of light source angle, brightness, color, and contrast.

[0070] In this step, the second GPU, through the AI system, multi-dimensionally adjusts the initial object model according to the original image data in combination with the image analysis results and the specified composition aesthetic preference data. The adjustment dimensions include light source angle, brightness, color, etc., to obtain the adjusted target object model.

[0071] Specifically, import the initial model: Load the previously established initial object model into the current environment. Apply adjustment rules: Based on the information extracted from the original image and scene requirements, define one or more sets of adjustment rules. These rules can be automated (based on the results predicted by a machine learning model) or manually set. For the process of performing adjustment operations, geometric transformations: such as scaling, rotation, and translation, change the position and size of the object. Material and texture mapping: Update attributes such as the color and reflectivity of the object's surface to make it more consistent with the lighting and environmental settings in the scene. Physical property settings: Adjust physical parameters such as mass and hardness to make the simulation more realistic. Add animation behavior: If needed, animation effects can also be added to the object, such as motion trajectories and deformations. Real-time feedback mechanism: Introduce a real-time feedback mechanism during the adjustment process to allow the user or system to monitor the adjustment effect and make fine-tuning as needed. Then, multi-dimensional verification, that is, visual consistency check: Ensure that the adjusted model visually matches the original image and the specified scene. Interaction test: For dynamic or interactive objects, test whether their responses are natural and smooth. Performance evaluation: Measure the rendering time and memory occupancy of the adjusted model to ensure that it can run properly under the expected hardware conditions.

[0072] Step S150, perform image rendering on the target object model through the second GPU to obtain the image rendering result corresponding to the original image data under the specified scene requirement data.

[0073] In this step, the second GPU performs image rendering based on the target object model to obtain the image rendering result corresponding to the original image data. Specifically, utilize the powerful parallel computing ability of the second GPU to decompose the rendering task into multiple small tasks for concurrent execution, such as color calculation and depth testing for each pixel. Adopt various optimization means, such as LOD (Level of Detail) technology and instanced rendering, to balance quality and performance.

[0074] As an optional implementation manner, the GPU device further includes a third GPU; after analyzing the original image data using an AI algorithm through the first GPU, obtain the original image analysis result; perform image rendering on the target object model through the second GPU to obtain the image rendering result corresponding to the original image data under the specified scene requirement data, including: performing image rendering on the target object model according to the specified low-pixel requirement data through the third GPU to obtain the initial image rendering result; reading the original image analysis result through the second GPU, and performing refined adjustment processing on the initial image rendering result according to the original image analysis result according to the specified high-pixel requirement data to adjust the pixel increase of the initial image rendering result to obtain the final image rendering result; wherein, the pixels corresponding to the specified high-pixel requirement data are higher than those corresponding to the specified low-pixel requirement data.

[0075] By using the third GPU to perform preliminary rendering according to lower pixel requirements, a roughly correct visual feedback can be quickly obtained. This is very useful for application scenarios that require frequent adjustment and viewing of effects (such as real-time interactive design or game development), because it allows developers to iterate on the design faster, enabling quick preview and iteration. Moreover, less computing resources are required for low-resolution rendering, so it can be completed faster without affecting system performance. This step frees up valuable GPU time and computing power for subsequent high-resolution refinement processing, achieving optimized resource allocation. Furthermore, the second GPU makes fine adjustments to the results of the preliminary rendering based on the analysis results of the original image, ensuring that the final output has a higher pixel density and better visual quality. Since there is already a preliminary low-resolution version as a basis, this step can focus more on adding necessary details and corrections, enhancing details and ensuring quality, rather than building the entire scene from scratch. In addition, compared to directly completing all rendering work at the highest pixel requirements at once, this method reduces the overall amount of computation. The preliminary rendering only needs to meet basic visualization needs, while the fine adjustment focuses on where it is really needed, thus reducing the overall computational complexity and time overhead, and lowering the total computational cost. This method can flexibly adjust the difference in pixel requirements between the two stages according to different application scenarios, giving priority to speed when hardware resources are limited or maximizing the use of available resources when pursuing extreme image quality, improving adaptability and flexibility.

[0076] Through a phased rendering strategy, that is, first quickly generating the initial image rendering result with lower pixel requirements and then making fine adjustments based on the analysis results of the original image to improve pixel quality, the best balance between efficiency and quality can be achieved, significantly improving the image rendering efficiency while ensuring high-quality output.

[0077] Exemplarily, the GPU device is set in the in-vehicle device, and the in-vehicle device corresponds to an in-vehicle user; as Figure 2 shown, the second GPU reads the analysis results of the original image and makes fine adjustment processing on the initial image rendering result according to the specified high-pixel requirement data to adjust the pixel increase of the initial image rendering result and obtain the final image rendering result, including:

[0078] Step S210, obtaining the user operation for the in-vehicle device and analyzing the composition aesthetic preference data corresponding to the in-vehicle user through the AI system according to the user operation;

[0079] Step S220, reading the composition aesthetic preference data through the second GPU and performing composition adjustment processing on the initial image rendering result according to the composition aesthetic preference data to adjust the composition style of the initial image rendering result to conform to the composition aesthetic preference data and obtain the first image rendering result;

[0080] Step S230, reading the original image analysis result through the second GPU, and performing fine adjustment processing on the first image rendering result according to the original image analysis result and the specified high pixel requirement data, so as to adjust the pixel height of the first image rendering result to obtain the final second image rendering result.

[0081] Through the personalized image rendering method, it combines the user's composition aesthetic preference and high-pixel fine adjustment. The most important beneficial effect of this method is to improve the personalization and satisfaction of the user experience. Specifically, the AI ​​system analyzes the composition aesthetic preference of the in-vehicle user to ensure that the final generated image not only meets the general aesthetic standards, but also fits the user's personal aesthetics, which improves the user's recognition and satisfaction with the product or service. Moreover, by first performing aesthetic-based composition adjustment and then performing high-pixel fine adjustment, the waste of computing resources that may be caused by operating directly at high resolution is avoided. The staged processing method enables computing resources to be used more effectively, while also speeding up the processing speed and achieving efficient resource utilization. The final second image rendering result takes into account the user's aesthetic needs and meets the high-pixel requirements, thereby providing a high-quality visual experience and achieving high-quality output. It can be seen that through the above processing method, a highly personalized and high-quality image rendering service can be provided without sacrificing performance, greatly improving the user experience.

[0082] In the embodiments of the present application, by allocating tasks to two independent GPUs (the first GPU and the second GPU), computationally intensive tasks such as object recognition and model establishment can be carried out simultaneously with scene adjustment and final rendering. This reduces the load on a single GPU and fully utilizes the advantages of multi-core in modern GPU architectures. The first GPU is responsible for analyzing the original image data and establishing an initial object model, which is a relatively complex but one-time process; while the second GPU focuses on optimizing and rendering these models according to specific scene requirements. Such a division of labor allows each GPU to concentrate on the most suitable tasks, realizing intelligent task allocation and improving the overall work efficiency. Moreover, considering the specific requirements of different application scenarios (such as intelligent vehicles, autonomous driving, etc.), this method allows customized parameter adjustment for each case. This means that in practical applications, the rendering effect is more in line with expectations, reducing unnecessary computational overhead. For example, in some cases, a very high level of detail or complex lighting effects are not required, achieving rendering optimization for specific scenes. Also, multi-dimensional adjustments such as light source angle, brightness, color, and contrast are carried out after modeling, rather than directly acting on the original image data. This method avoids repeated processing of the same image information because once the object model is established, its attributes can be modified more effectively without having to re-parse the entire scene. In addition, by using AI algorithms for object recognition and feature extraction, it is possible to better understand the input data, thereby generating a more compact and effective 3D model. This not only helps reduce the storage space requirements and efficiently utilize hardware resources, but also reduces the amount of data in the subsequent processing stage, thereby improving the working efficiency of the GPU. Moreover, by using the 3D engine distributedly by the first GPU to establish the initial object model corresponding to each object to be rendered, this approach can accelerate the model establishment process. Especially when faced with a large number of complex objects, distributed computing can significantly shorten the time. In summary, this method effectively improves the operating efficiency of the GPU by reasonably planning the task process, effectively utilizing hardware resources, and specifically adapting to the requirements of different application scenarios.

[0083] The above steps will be introduced in detail below.

[0084] In some embodiments, a Unity engine is set in the second GPU; the above-mentioned image rendering is performed through the second GPU based on the target object model to obtain the image rendering result corresponding to the original image data under the specified scene requirement data, which may specifically include the following steps:

[0085] Accelerate the second GPU through ShaderGraph and ComputeShader of the Unity engine, and pre-compute multiple target matrices in the target object model based on the target object model using ScriptingDefineSymbols and CustomEditor of the Unity engine;

[0086] Perform distributed computing on multiple target matrices using NetworkManager and MultiplayerAPI of the Unity engine based on multiple target matrices to obtain a distributed computing result, and perform image rendering on the target object model through the accelerated second GPU based on the distributed computing result to obtain an image rendering result corresponding to the original image data under the specified scene requirement data.

[0087] Accelerating the second GPU through ShaderGraph and ComputeShader of the Unity engine can make full use of the powerful parallel computing ability of the GPU, thus greatly accelerating the pre-computation speed of multiple target matrices in the target object model. Moreover, pre-computing multiple target matrices in the target object model using ScriptingDefineSymbols and CustomEditor of the Unity engine reduces the computational burden during real-time rendering, making the rendering process more efficient. By performing distributed computing using NetworkManager and MultiplayerAPI of the Unity engine based on multiple target matrices, the computational tasks originally borne by a single device are distributed to multiple nodes for execution, which not only improves the computing speed but also enables handling more complex scenarios and larger data sets. Finally, performing image rendering on the target object model on the accelerated second GPU can obtain a high-quality image rendering result under the specified scene requirements while maintaining high rendering performance. In summary, this method can greatly improve the speed and quality of image rendering, especially in the case of processing complex scenarios or large amounts of data, ensuring the best visual experience and response speed in applications with high-performance requirements (such as game development, virtual reality, etc.). This not only enhances the user experience but also improves the competitiveness of the application. By combining the features of the Unity engine, ShaderGraph, ComputeShader, and distributed computing technology, the method for accelerating the complex image rendering process can significantly improve the efficiency and performance of image rendering.

[0088] In some embodiments, the acceleration processing of the second GPU through the ShaderGraph and ComputeShader of the Unity engine may specifically include the following steps: Dynamically allocate the resources of the second GPU through the following formula: GPUResources(x) = γ(x) × ObjectImportance(x), where γ(x) is the weight varying with position, and ObjectImportance(x) is the importance of the object at position x; Adjust the task priority of the second GPU through the following formula: GPUPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x), where δ(t) and ε(t) are the weights varying with time, TaskImportance(t, x) is the importance varying with time at position x, and TaskUrgency(t, x) is the task priority varying with time at position x.

[0089] In the embodiments of the present application, GPU acceleration is achieved by using the ShaderGraph and ComputeShader of Unity. By introducing dynamic resource allocation and task priority adjustment formulas, more intelligent and efficient GPU resource management and task scheduling can be realized. The main beneficial effects of this method are that it can significantly improve the response speed and resource utilization efficiency of the system, which are specifically manifested in the following aspects:

[0090] Optimize resource allocation: The formula GPUResources(x) = γ(x) × ObjectImportance(x) dynamically allocates the resources of the second GPU according to the importance of the object at different positions. This approach ensures that resources are allocated to the places where they are most needed, improves the rendering quality and efficiency, and avoids resource waste at the same time.

[0091] Intelligent task priority adjustment: The formula GPUPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x) takes into account the time importance and urgency of the task, and thus dynamically adjusts the task priority. This enables the system to more flexibly respond to real-time changing requirements, ensures that critical tasks are processed in a timely manner, and enhances the adaptability and flexibility of the system.

[0092] Enhance user experience: By combining the above two mechanisms, it can be ensured that visually important elements (such as the object the user is focusing on or the main character in the scene) receive more computing resources, while elements that have less impact on the user experience are processed with fewer resources. This not only improves the image quality but also guarantees a smooth interaction experience, especially in complex scenes or high-load situations.

[0093] Improve overall performance: Intelligent resource allocation and task priority management reduce unnecessary computational overhead, enabling the GPU to be in the best working state at all times, thereby improving the performance and stability of the entire system.

[0094] In summary, this method can greatly optimize GPU resource management and task scheduling strategies, thus bringing higher performance and a better user experience, especially in application scenarios with strict requirements for real-time performance and resource utilization efficiency.

[0095] In some embodiments, pre-computing multiple target matrices in the target object model based on the target object model using ScriptingDefineSymbols and CustomEditor of the Unity engine may specifically include the following steps:

[0096] Determine the pre-computation frequency through the following formula according to the specified parameters that change over time: PreconputeFrequency(t) = α(t) × SceneChangeRate(t) + β(t), where α(t) and β(t) are specified parameters that change over time;

[0097] Based on the target object model, use ScriptingDefineSymbols and CustomEditor of the Unity engine to pre-compute multiple target matrices in the target object model according to the pre-computation frequency through the following formula:

[0098] PrecomputePriority(x) = γ(x) × ObjectImportance(x), where γ(x) is the weight of the target object model that changes with position, and ObjectImportance(x) is the importance of the target object model at position x;

[0099] PrecomputeTaskPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x), where δ(t) and ε(t) are time-varying weights, TaskImportance(t, x) is the importance of the target object model varying with time at position x, and TaskUrgency(t, x) is the task priority of the target object model varying with time at position x.

[0100] By combining dynamic precomputation frequency adjustment with intelligent task priority management, it aims to optimize the processing efficiency of the target object model in the Unity engine, significantly improving development and runtime performance while ensuring that critical tasks and important objects are given priority.

[0101] Dynamic adaptation to scene changes: Through the formula PrecomputeFrequency(t) = α(t) × SceneChangeRate(t) + β(t), this method can dynamically adjust the precomputation frequency according to the scene change rate. This means that when the scene changes rapidly, the system increases the precomputation frequency to maintain the response speed; while when the scene is relatively stable, it reduces the precomputation frequency to save resources. This flexibility enables the system to utilize computing resources more efficiently.

[0102] Optimizing the priority of precomputation tasks: Use the formulas PrecomputePriority(x) = γ(x) × ObjectImportance(x) and PrecomputeTaskPriority(t, x) = δ(t) × TaskImportance(t,x) + ε(t) × TaskUrgency(t, x) to determine which target matrices should be precomputed first. This ensures that visually or logically more important elements are given higher priority, thereby improving the quality of the end-user experience while ensuring that urgent tasks are not delayed.

[0103] Enhancing development efficiency and flexibility: With the help of the ScriptingDefineSymbols and CustomEditor functions of the Unity engine, developers can automate complex target matrix precomputation tasks according to the precomputation frequency. This method not only simplifies the development process but also allows developers to easily customize precomputation strategies to adapt to different project requirements and technical limitations.

[0104] Enhancing runtime performance: Through the above mechanisms, without affecting the user experience, it can optimize the background processing process, reduce unnecessary computations, thereby reducing CPU and GPU loads and improving the overall runtime efficiency.

[0105] In summary, this method achieves efficient resource management and optimized task scheduling, enabling developers to maximize the utilization of available resources while ensuring high-quality output, providing a smooth and responsive application experience. In addition, this method also enhances the flexibility and efficiency of development, providing strong support for creating complex interactive content.

[0106] In some embodiments, the above-mentioned distributed computing of multiple target matrices using the NetworkManager and MultiplayerAPI of the Unity engine based on multiple target matrices to obtain a distributed computing result may specifically include the following steps:

[0107] Determine the dynamic adjustment task assignment strategy through the following formula: TaskAssignment(t) = arg max(NetworkQuality_i(t) × TaskPriority_i(t)), where NetworkQuality_i(t) is the network quality of the i-th node at time point t, and TaskPriority_i(t) is the priority of the i-th task at time point t;

[0108] Dynamically allocate computing resources through the following formula: ComputeResources(x) = γ(x) × TaskDemand(x), where γ(x) is the weight varying with position, and TaskDemand(x) is the demand of the task at position x;

[0109] Adjust the task assignment priority through the following formula: TaskPriority(t, x) = δ(t) × TaskImportance(t, x) + ε(t) × TaskUrgency(t, x), where δ(t) and ε(t) are weights varying with time, TaskImportance(t, x) is the importance of the target matrix varying with time at position x, and TaskUrgency(t, x) is the task priority of the target matrix varying with time at position x;

[0110] Based on multiple target matrices, use the dynamically allocated computing resources in the Unity engine to perform distributed computing on multiple target matrices according to the task assignment priority through the dynamic adjustment task assignment strategy to obtain a distributed computing result.

[0111] By combining the dynamic task assignment strategy, intelligent allocation of computing resources, and priority adjustment, it aims to optimize the processing efficiency of multiple target matrices in a distributed computing environment, achieving efficient utilization of distributed computing resources and task scheduling, thereby significantly improving the system performance and response speed.

[0112] Intelligent task assignment: By using the formula TaskAssignment(t) = arg max(NetworkQuality_i(t)× TaskPriority_i(t)), ensure that each task is assigned to the node with the optimal network quality and best meeting the task priority requirements for execution. This not only maximizes the execution efficiency of a single task but also ensures the load balance of the entire system.

[0113] Flexible computing resource allocation: Use the formula ComputeResources(x) = γ(x) × TaskDemand(x) to dynamically allocate computing resources according to the demands of tasks at different locations. This method can reasonably allocate resources according to actual demands, avoid resource waste or insufficiency, and improve resource utilization.

[0114] Dynamic priority adjustment: Through the formula TaskPriority(t, x) = δ(t) × TaskImportance(t,x) + ε(t) × TaskUrgency(t, x), adjust the task priority in real time according to changes in time, task importance, and urgency. This enables critical and urgent tasks to be processed in a timely manner, enhancing the flexibility and responsiveness of the system.

[0115] Improve distributed computing efficiency: Based on the dynamically allocated computing resources in the Unity engine, perform distributed computing on multiple target matrices according to the above strategies, which can effectively reduce computing latency and improve data processing speed. At the same time, since tasks are reasonably assigned to the most suitable computing nodes, unnecessary data transmission overhead is reduced, further enhancing the overall computing efficiency.

[0116] In summary, this method realizes efficient distributed computing resource management and task scheduling optimization, can maximize the utilization of available resources while ensuring the efficient completion of tasks, and provides fast and reliable computing services. In addition, this method also enhances the adaptability and scalability of the system, providing strong support for creating complex large-scale distributed computing applications. In this way, developers can ensure the high-performance operation of the system in a complex environment while simplifying the development and management processes.

[0117] Figure 3 A schematic structural diagram of a Unity image rendering device based on the AI algorithm of the YTS system is provided. This device can be applied to a GPU device, and the GPU device includes a first GPU and a second GPU. As Figure 3 shown, the Unity image rendering device 300 based on the AI algorithm of the YTS system includes:

[0118] An acquisition module 301, configured to acquire original image data to be processed;

[0119] An identification module 302, configured to analyze the original image data by using an AI algorithm through the first GPU and perform object identification on the original image data to obtain a plurality of objects to be rendered in the original image data;

[0120] A building module 303, configured to distributively build an initial object model corresponding to each object to be rendered by using a 3D engine through the first GPU based on the plurality of objects to be rendered;

[0121] An adjustment module 304, configured to perform multi-dimensional adjustment on the initial object model according to the original image data through the second GPU in combination with specified scene requirement data to obtain an adjusted target object model; wherein, the specified scene requirement data includes at least one of intelligent vehicle-mounted scene requirement data, autonomous driving scene requirement data, vehicle-road connection scene requirement data, vehicle-vehicle connection scene requirement data, vehicle-person connection scene requirement data, and vehicle-person-road connection scene requirement data; the adjustment dimensions of the multi-dimensional adjustment include at least one of light source angle, brightness, color, and contrast;

[0122] A rendering module 305, configured to perform image rendering on the target object model through the second GPU to obtain an image rendering result corresponding to the original image data under the specified scene requirement data.

[0123] The Unity image rendering device based on the YTS system AI algorithm provided by the embodiments of the present application has the same technical features as the Unity image rendering method based on the YTS system AI algorithm provided by the above embodiments, so it can also solve the same technical problems and achieve the same technical effects.

[0124] An electronic device provided by an embodiment of the present application, as Figure 4 shown, the electronic device 400 includes a processor 402 and a memory 401. A computer program that can run on the processor is stored in the memory. When the processor executes the computer program, the steps of the method provided by the above embodiments are implemented.

[0125] See Figure 4 , the electronic device further includes: a bus 403 and a communication interface 404. The processor 402, the communication interface 404, and the memory 401 are connected through the bus 403; the processor 402 is configured to execute an executable module stored in the memory 401, such as a computer program.

[0126] Among them, the memory 401 may include a high-speed random access memory (Random Access Memory, referred to as RAM), and may also include non-volatile memory, such as at least one disk memory. The communication connection between this system network element and at least one other network element is realized through at least one communication interface 404 (which can be wired or wireless), and the Internet, wide area network, local area network, metropolitan area network, etc. can be used.

[0127] The bus 403 can be an ISA bus, a PCI bus, an EISA bus, etc. The bus can be divided into an address bus, a data bus, a control bus, etc. For the sake of convenience of representation, Figure 4 only a bidirectional arrow is used in the figure, but it does not mean that there is only one bus or one type of bus.

[0128] Among them, the memory 401 is used to store a program. After receiving an execution instruction, the processor 402 executes the program. The method executed by the device defined by the process disclosed in any embodiment of the present application can be applied to the processor 402 or implemented by the processor 402.

[0129] The processor 402 may be an integrated circuit chip with the ability to process signals. In the implementation process, each step of the above method can be completed by the integrated logic circuit of the hardware in the processor 402 or the instructions in the form of software. The above-mentioned processor 402 may be a general-purpose processor, including a central processing unit (CPU for short), a network processor (NP for short), etc.; it may also be a digital signal processor (DSP for short), an application specific integrated circuit (ASIC for short), a field-programmable gate array (FPGA for short), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components. It can implement or execute the various methods, steps and logic block diagrams disclosed in the embodiments of the present application. The general-purpose processor may be a microprocessor or the processor may also be any conventional processor, etc. The steps of the method disclosed in combination with the embodiments of the present application can be directly embodied as being executed and completed by the hardware decoding processor, or executed and completed by a combination of the hardware and software modules in the decoding processor. The software module may be located in a mature storage medium in the art such as a random access memory, a flash memory, a read-only memory, a programmable read-only memory, or an electrically erasable programmable memory, a register, etc. This storage medium is located in the memory 401, and the processor 402 reads the information in the memory 401 and combines its hardware to complete the steps of the above method.

[0130] Corresponding to the above-mentioned Unity image rendering method based on the YTS system AI algorithm, an embodiment of the present application also provides a computer-readable storage medium. The computer-readable storage medium stores computer-executable instructions. When the computer-executable instructions are called and run by a processor, the computer-executable instructions cause the processor to run the steps of the above-mentioned Unity image rendering method based on the YTS system AI algorithm.

[0131] The Unity image rendering device based on the YTS system AI algorithm provided by the embodiments of the present application may be specific hardware on a device or software or firmware installed on the device, etc. For the device provided by the embodiments of the present application, its implementation principle and the technical effects produced are the same as those of the foregoing method embodiments. For the sake of brief description, for the parts not mentioned in the device embodiments, reference may be made to the corresponding content in the foregoing method embodiments. Those skilled in the art can clearly understand that for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can all refer to the corresponding processes in the above method embodiments, and will not be repeated here.

[0132] In the embodiments provided in the present application, it should be understood that the disclosed devices and methods can be implemented in other ways. The device embodiments described above are merely illustrative. For example, the division of the units is only a logical function division. In actual implementation, there may be other division methods. For another example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the displayed or discussed coupling or direct coupling or communication connection between each other can be through some communication interfaces. The indirect coupling or communication connection of the devices or units can be in electrical, mechanical or other forms.

[0133] For another example, the flowcharts and block diagrams in the accompanying drawings show the possible architectures, functions and operations of the devices, methods and computer program products according to multiple embodiments of the present application. In this regard, each block in the flowchart or block diagram may represent a module, a program segment, or a part of code, and the module, program segment, or part of code contains one or more executable instructions for implementing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the blocks may occur in a different order than that marked in the accompanying drawings. For example, two consecutive blocks can actually be executed substantially in parallel, and they can sometimes be executed in the reverse order, depending on the functions involved. It should also be noted that each block in the block diagram and / or flowchart, and the combination of blocks in the block diagram and / or flowchart, can be implemented by a dedicated hardware-based system for performing the specified functions or actions, or can be implemented by a combination of dedicated hardware and computer instructions.

[0134] The units described as separate components may or may not be physically separated. The components shown as units may or may not be physical units, that is, they may be located in one place, or may be distributed to multiple network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0135] In addition, the functional units in the embodiments provided in the present application can be integrated in one processing unit, or each unit can exist physically alone, or two or more units can be integrated in one unit.

[0136] When the above-mentioned function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a part of this technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the Unity image rendering method based on the YTS system AI algorithm described in various embodiments of this application. The aforementioned storage medium includes: various media such as USB flash drives, mobile hard disks, read-only memories (ROM), random access memories (RAM), magnetic disks, or optical discs that can store program codes.

[0137] It should be noted that: similar reference numerals and letters represent similar items in the following drawings. Therefore, once an item is defined in one drawing, it does not need to be further defined and explained in subsequent drawings. In addition, the terms "first", "second", "third", etc. are only used for descriptive distinction and cannot be understood as indicating or implying relative importance.

[0138] Finally, it should be noted that: the above-mentioned embodiments are only specific implementation manners of this application, used to illustrate the technical solution of this application, rather than limiting it. The protection scope of this application is not limited thereto. Although this application has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that: any person skilled in the art within the technical scope disclosed in this application can still modify the technical solution recorded in the foregoing embodiments, or can easily think of changes, or perform equivalent replacements on some of the technical features; and these modifications, changes, or replacements do not make the essence of the corresponding technical solution deviate from the scope of the technical solution of the embodiments of this application. All should be covered within the protection scope of this application. Therefore, the protection scope of this application should be subject to the protection scope of the claims.

Claims

1. A Unity image rendering method based on the YTS system AI algorithm, characterized in that: Applied to a GPU device, the GPU device includes a first GPU and a second GPU, the method includes: Obtaining raw image data to be processed; The first GPU uses an AI algorithm to analyze the original image data and perform object recognition on the original image data to obtain a plurality of objects to be rendered in the original image data; Based on the multiple objects to be rendered, using the first GPU and a 3D engine to establish an initial object model corresponding to each object to be rendered in a distributed manner; According to the original image data, the initial object model is adjusted in multiple dimensions by the second GPU in combination with the specified scene requirement data to obtain an adjusted target object model; wherein the specified scene requirement data includes at least one of intelligent vehicle scene requirement data, automatic driving scene requirement data, vehicle-road interconnection scene requirement data, vehicle-to-vehicle interconnection scene requirement data, human-to-vehicle interconnection scene requirement data and human-to-vehicle-road interconnection scene requirement data; the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color and contrast; the GPU device also includes a third GPU; the original image analysis result is obtained by analyzing the original image data by the first GPU using an AI algorithm; The target object model is rendered by the third GPU according to the specified low pixel requirement data to obtain an initial image rendering result; the original image analysis result is read by the second GPU, and the initial image rendering result is finely adjusted according to the specified high pixel requirement data based on the original image analysis result to increase the pixel height of the initial image rendering result to obtain a final image rendering result; wherein the pixels corresponding to the specified high pixel requirement data are higher than the specified low pixel requirement data.

2. The method according to claim 1, characterized in that: The GPU device is arranged in a vehicle-mounted device, and the vehicle-mounted device corresponds to a vehicle-mounted user; the second GPU is used to read the original image analysis result, and the initial image rendering result is finely adjusted according to the original image analysis result and the specified high pixel requirement data, so as to adjust the pixel height of the initial image rendering result to obtain the final image rendering result, including: Acquire a user operation on the in-vehicle device, and analyze the composition aesthetic preference data corresponding to the in-vehicle user through an AI system according to the user operation; The composition aesthetic preference data is read by the second GPU, and composition adjustment processing is performed on the initial image rendering result according to the composition aesthetic preference data, so as to adjust the composition style of the initial image rendering result to conform to the composition aesthetic preference data, thereby obtaining a first image rendering result; The original image analysis result is read by the second GPU, and the first image rendering result is finely adjusted according to the original image analysis result and the specified high pixel requirement data to adjust the pixel height of the first image rendering result to obtain the final second image rendering result.

3. The method according to claim 1, characterized in that The plurality of objects to be rendered include any one or more of the following: Vehicles, buildings, trees, and people.

4. The method according to claim 1, characterized in that: The second GPU is provided with a Unity engine; the image rendering is performed by the second GPU based on the target object model to obtain an image rendering result corresponding to the original image data under the specified scene requirement data, including: The second GPU is accelerated by ShaderGraph and ComputeShader of the Unity engine, and multiple target matrices in the target object model are pre-calculated by ScriptingDefineSymbols and CustomEditor of the Unity engine based on the target object model; Based on the multiple target matrices, the NetworkManager and MultiplayerAPI of the Unity engine are used to perform distributed calculations on the multiple target matrices to obtain distributed calculation results, and based on the distributed calculation results, image rendering is performed on the target object model through the second GPU after acceleration processing to obtain the image rendering result corresponding to the original image data under the specified scene requirement data.

5. The method according to claim 4, characterized in that The accelerating processing of the second GPU by using ShaderGraph and ComputeShader of the Unity engine includes: The resources of the second GPU are dynamically allocated by the following formula: GPUResources(x)=γ(x)×ObjectImportance(x), where γ(x) is a weight that varies with position, and ObjectImportance(x) is the importance of the object at position x; The task priority of the second GPU is adjusted by the following formula: GPUPriority(t,x)=δ(t)×TaskImportance(t,x)+ε(t)×TaskUrgency(t,x), where δ(t) and ε(t) are weights that change with time, TaskImportance(t,x) is the importance that changes with time at position x, and TaskUrgency(t,x) is the task priority that changes with time at position x.

6. The method according to claim 4, characterized in that The method of precalculating a plurality of target matrices in the target object model by using ScriptingDefineSymbols and CustomEditor of the Unity engine based on the target object model includes: The pre-calculation frequency is determined by the following formula according to the specified parameters that vary with time: PrecomputeFrequency(t)=α(t)×SceneChangeRate(t)+β(t), where α(t) and β(t) are the specified parameters that vary with time; Based on the target object model, multiple target matrices in the target object model are precalculated using the ScriptingDefineSymbols and CustomEditor of the Unity engine according to the precalculation frequency using the following formula: PrecomputePriority(x)=γ(x)×ObjectImportance(x), where γ(x) is the weight of the target object model that varies with position, and ObjectImportance(x) is the importance of the target object model at position x; PrecomputeTaskPriority(t,x)=δ(t)×TaskImportance(t,x)+ε(t)×TaskUrgency(t,x), where δ(t) and ε(t) are weights that change over time, TaskImportance(t,x) is the importance of the target object model at position x that changes over time, and TaskUrgency(t,x) is the task priority of the target object model at position x that changes over time.

7. The method according to claim 4, characterized in that The method of performing distributed calculations on the multiple target matrices using the NetworkManager and MultiplayerAPI of the Unity engine based on the multiple target matrices to obtain distributed calculation results includes: The dynamic adjustment task assignment strategy is determined by the following formula: TaskAssignment(t)=arg max( (t)× (t)), where (t) is the network quality of the ith node at time t, (t) is the priority of the i-th task at time t; Compute resources are dynamically allocated using the following formula: ComputeResources(x)=γ(x)×TaskDemand(x), where γ(x) is a weight that varies with location, and TaskDemand(x) is the demand for the task at location x; The task allocation priority is adjusted by the following formula: TaskPriority(t,x)=δ(t)×TaskImportance(t,x)+ε(t)×TaskUrgency(t,x), where δ(t) and ε(t) are weights that vary with time, TaskImportance(t,x) is the importance of the target matrix at position x that varies with time, and TaskUrgency(t,x) is the task priority of the target matrix at position x that varies with time; Based on the multiple target matrices, the computing resources dynamically allocated in the Unity engine are utilized to perform distributed computing on the multiple target matrices according to the task allocation priority through the dynamically adjusted task allocation strategy to obtain distributed computing results.

8. A Unity image rendering device based on the YTS system AI algorithm, characterized in that: Applied to a GPU device, the GPU device includes a first GPU and a second GPU, and the apparatus includes: An acquisition module, used for acquiring raw image data to be processed; an identification module, configured to analyze the original image data by using an AI algorithm through the first GPU and perform object identification on the original image data to obtain a plurality of objects to be rendered in the original image data; An establishing module, configured to establish an initial object model corresponding to each of the objects to be rendered in a distributed manner by using a 3D engine through the first GPU based on the multiple objects to be rendered; an adjustment module, configured to perform multi-dimensional adjustment on the initial object model according to the original image data through the second GPU in combination with specified scene requirement data to obtain an adjusted target object model; wherein the specified scene requirement data includes at least one of intelligent vehicle scene requirement data, automatic driving scene requirement data, vehicle-road interconnection scene requirement data, vehicle-to-vehicle interconnection scene requirement data, human-to-vehicle interconnection scene requirement data, and human-to-vehicle-road interconnection scene requirement data; the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color, and contrast; the GPU device also includes a third GPU; the original image analysis result is obtained by analyzing the original image data using an AI algorithm through the first GPU; A rendering module is used to perform image rendering on the target object model according to the specified low pixel requirement data through the third GPU to obtain an initial image rendering result; read the original image analysis result through the second GPU, and perform fine adjustment processing on the initial image rendering result according to the specified high pixel requirement data based on the original image analysis result to adjust the pixel height of the initial image rendering result to obtain a final image rendering result; wherein the pixels corresponding to the specified high pixel requirement data are higher than the specified low pixel requirement data.

9. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores computer-executable instructions. When the computer-executable instructions are called and executed by a processor, the computer-executable instructions prompt the processor to execute the method according to any one of claims 1 to 7.

Images