Rendering method and device based on AI algorithm of YTS system and storage medium

Abstract

The invention provides a rendering method and device based on an AI algorithm of a YTS system, and a storage medium, relates to the technical field of image rendering, and solves the technical problem of relatively low GPU operation efficiency in an image rendering process. The method comprises the following steps: acquiring original image data to be processed; analyzing the original image data by using an AI algorithm through the first GPU, and performing object recognition on the original image data to obtain a plurality of to-be-rendered objects in the original image data; based on the plurality of to-be-rendered objects, establishing an initial object model corresponding to each to-be-rendered object in a distributed manner by using a 3D engine through a first GPU; according to the original image data, performing multi-dimensional adjustment on the initial object model through a second GPU in combination with specified scene requirement data to obtain an adjusted target object model; and performing 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.

Description

Technical Field

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

[0002] Image rendering is the process of converting three-dimensional light energy transfer processing into a two-dimensional image. The scenes and entities are represented in three-dimensional form, which is closer to the real world and easier to manipulate and transform. The display devices of graphics are mostly two-dimensional rasterized displays and dot matrix printers. The representation of three-dimensional entity scenes from N-dimensional gratings and dot matrix is ​​image rendering, that is, rasterization. The raster display can be regarded as a pixel matrix. Any graphic displayed on the raster display is actually a collection of pixels with one or more colors and grayscales.

[0003] Graphics Processing Unit (GPU), also known as display core, display chip, video processor, is a coprocessor used to process images and graphics operations. It provides more realistic rendering effects in image processing and other application fields. However, the current GPU performance is low, resulting in low GPU operating efficiency 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 YTS system AI algorithm to solve the technical problem of low GPU operating efficiency during image rendering.

[0005] In a first aspect, the present application provides a Unity image rendering method based on a YTS system artificial intelligence (AI) algorithm, which is applied to a graphics processing unit (GPU) device, wherein the GPU device includes a first GPU and a second GPU, and 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; and the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color, and contrast; 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.

[0006] In a possible implementation, the GPU device further includes a third GPU; the first GPU analyzes the original image data using an AI algorithm to obtain an original image analysis result; and the second GPU performs image rendering 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: Performing image rendering on the target object model according to the specified low-pixel requirement data by the third GPU 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 original image analysis result and the specified high pixel requirement data to adjust the pixel height 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 the specified low pixel requirement data.

[0007] In a possible implementation, the GPU device is set 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 fine adjustment processing on the initial image rendering result according to the original image analysis result and the specified high pixel requirement data 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.

[0008] In a possible implementation, the multiple objects to be rendered include any one or more of the following: Vehicles, buildings, trees, and people.

[0009] In a possible implementation, a Unity engine is provided in the second GPU; performing image rendering 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 includes: 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.

[0010] In a possible implementation, 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.

[0011] In a possible implementation, precalculating multiple target matrices in the target object model based on the target object model using ScriptingDefineSymbols and CustomEditor of the Unity engine 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.

[0012] In a possible implementation, 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(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; 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.

[0013] In a second aspect, the present application provides a Unity image rendering device based on a YTS system AI algorithm, which is applied to a GPU device, wherein the GPU device includes a first GPU and a second GPU, and the device 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, autonomous 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; and the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color, and contrast; A rendering module is used 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.

[0014] In a third aspect, the present application provides an electronic device, comprising a memory and a processor, wherein the memory stores a computer program executable on the processor, and when the processor executes the computer program, the method described in the first aspect is implemented.

[0015] In a fourth aspect, the present application further provides a computer-readable storage medium, which 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 described in the first aspect.

[0016] This application brings the following beneficial effects: The present application provides a rendering method, device and storage medium based on the AI ​​algorithm of the YTS system, which can obtain raw image data to be processed, analyze the raw image data by using the AI ​​algorithm through the first GPU and perform object recognition on the raw image data to obtain multiple objects to be rendered in the raw image data, and establish an initial object model corresponding to each object to be rendered in a distributed manner through the first GPU using a 3D engine based on the multiple objects to be rendered, and perform multi-dimensional adjustment on the initial object model according to the raw 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, automatic driving scene requirement data, vehicle-road interconnection scene requirement data, vehicle-to-vehicle interconnection scene requirement data, human-vehicle interconnection scene requirement data and human-vehicle-road interconnection scene requirement data, and the multi-dimensional The adjustment dimension includes at least one of the light source angle, brightness, color, and contrast. Based on the target object model, the image rendering is performed by the second GPU to obtain the image rendering result corresponding to the original image data under the specified scene requirement data. In this solution, by assigning the work to two independent GPUs (the first GPU and the second GPU), computationally intensive tasks such as object recognition and model building can be performed simultaneously with scene adjustment and final rendering, which reduces the load of a single GPU and makes full use of the advantages of multiple 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, adjusting, and rendering these models according to specific scene requirements. Such division of labor can enable each GPU to focus on the most suitable task, realize intelligent task allocation, and improve overall work efficiency. Furthermore, considering the specific needs of different application scenarios (such as smart car-mounted, autonomous driving, etc.), this method allows customized parameter adjustments for each situation. This means that in practical applications, the rendering effect is more in line with expectations and reduces unnecessary computing overhead. For example, in some cases, very high levels of detail or complex lighting effects are not required, and rendering optimization for specific scenes is achieved. Moreover, multi-dimensional adjustments to light source angle, brightness, color, contrast, etc. are made after modeling, rather than directly acting on the original image data. This approach avoids repeated processing of the same image information, because once the object model is established, its properties can be modified more efficiently without having to reparse the entire scene. In addition, the use of AI algorithms for object recognition and feature extraction can better understand the input data, thereby generating a more compact and effective 3D model, which not only helps to reduce storage space requirements and efficiently utilize hardware resources, but also reduces the amount of data in the subsequent processing stage, thereby improving the efficiency of the GPU.Furthermore, the first GPU uses the 3D engine to distribute the initial object model corresponding to each object to be rendered. This approach can speed up the model building process, especially when facing a large number of complex objects, distributed computing can significantly shorten the time. In summary, this method effectively improves the GPU operating efficiency by reasonably planning the task flow, effectively utilizing hardware resources, and specifically adapting to the requirements of different application scenarios.

[0017] In order to make the above-mentioned objects, features and advantages of the present application more obvious and easy to understand, preferred embodiments are specifically cited below and described in detail with reference to the attached drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to more clearly illustrate the specific implementation methods of the present application or the technical solutions in the prior art, the drawings required for use in the specific implementation methods or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some implementation methods of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0019] Figure 1 A schematic diagram of the flow of a Unity image rendering method based on the YTS system AI algorithm provided in an embodiment of the present application; Figure 2 Another schematic diagram of the process of Unity image rendering method based on YTS system AI algorithm provided in an embodiment of the present application; Figure 3 A schematic diagram of the structure of a Unity image rendering device based on the YTS system AI algorithm provided in an embodiment of the present application; Figure 4 A schematic structural diagram of an electronic device provided in an embodiment of the present application is shown. DETAILED DESCRIPTION

[0020] In order to make the purpose, technical solution and advantages of the embodiments of the present application clearer, the technical solution of the present application will be clearly and completely described below in conjunction with the accompanying drawings. Obviously, the described embodiments are part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present application.

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

[0022] At present, the GPU operation efficiency in the image rendering process is low. Based on this, the embodiment of the present application provides a rendering method, device and storage medium based on the YTS system AI algorithm, which can solve the technical problem of low GPU operation efficiency in the image rendering process.

[0023] The embodiments of the present invention are further described below in conjunction with the accompanying drawings.

[0024] Figure 1 A flowchart of a Unity image rendering method based on the YTS system AI algorithm provided in an embodiment of the present application. The method is applied to a GPU device, and the GPU device includes a first GPU and a second GPU. Figure 1 As shown, the method includes: Step S110, obtaining original image data to be processed.

[0025] In the image rendering process provided by the embodiment of the present application, at least two GPUs (GPU distribution) are used: the first GPU is used for AI computing; the second GPU is used for rendering images. The original image data (picture or video) to be rendered is obtained.

[0026] In some cases, it may be necessary to perform preliminary processing on the original image. For example, resizing the image, converting the color mode, removing noise, annotating key information in the image, etc., to ensure that it is suitable for subsequent processing or analysis. Then, the collected image data is organized and stored according to certain rules to ensure easy access and management. After that, the quality of the image data is checked to ensure that it meets the expected standards. This step may include deleting damaged files and filtering out irrelevant or low-quality images.

[0027] In practical applications, the YTS (Unity TV Service) system in the embodiment of this application represents the Unity visual rendering service system. Unity is a real-time 3D interactive content creation and operation platform. All creators, including game development, art, architecture, car design, and film and television, use Unity to turn their ideas into reality. The platform provides a complete set of software solutions that can be used to create, operate, and realize any real-time interactive 2D and 3D content. Supported platforms include mobile phones, tablets, PCs, game consoles, augmented reality, and virtual reality devices.

[0028] Step S120 , using the first GPU to analyze the original image data using an AI algorithm and perform object recognition on the original image data to obtain a plurality of objects to be rendered in the original image data.

[0029] As an optional implementation, the plurality of 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, identifies the plurality of objects to be rendered (such as vehicles, buildings, trees, people, objects, etc.) in the original image data, Exemplarily, a pre-trained model is first selected, that is, a suitable object recognition pre-trained model is selected according to the task requirements, such as YOLO, Faster R-CNN, SSD, etc. Custom model (if necessary): In some cases, it may be necessary to fine-tune an existing model or build a new model from scratch to meet specific requirements. Load model: Load the selected model into memory and migrate it to the GPU for running. Then, the pre-processed image data is fed 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 box and remove redundant detection results. Then, the information of each recognized object is parsed from the output of the model, such as category, confidence score, location coordinates, etc. Generate a list of objects to be rendered: Based on the parsing results, an entry is created for each recognized object, containing all necessary information for subsequent rendering.

[0030] Step S130 : Based on the multiple objects to be rendered, an initial object model corresponding to each object to be rendered is established in a distributed manner by using a 3D engine through the first GPU.

[0031] In this step, the first GPU first establishes initial object models corresponding to the images to be rendered for the multiple objects to be rendered in a scattered and distributed manner at random, but no rendering has been done at this time.

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

[0033] 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. Parallel modeling process: for each object to be rendered, start the 3D engine instance on the corresponding GPU node and start to build the initial model of the object at the same time. Parameter optimization: set the optimal parameter configuration for each 3D engine instance to ensure modeling speed and quality.

[0034] Step S140 , performing multi-dimensional adjustments on the initial object model according to the original image data by using the second GPU in combination with the specified scene requirement data to obtain an adjusted target object model.

[0035] Among them, the specified scene requirement data includes at least one of the smart vehicle scene requirement data, automatic driving scene requirement data, vehicle-road interconnection scene requirement data, vehicle-to-vehicle interconnection scene requirement data, human-vehicle interconnection scene requirement data and human-vehicle-road interconnection scene requirement data; the adjustment dimension of the multi-dimensional adjustment includes at least one of the light source angle, brightness, color and contrast.

[0036] In this step, the second GPU uses the AI ​​system to perform multi-dimensional adjustments to the initial object model based on the original image data combined with the image analysis results and the specified composition aesthetic preference data, where the adjustment dimensions include light source angle, brightness, color, etc., to obtain an adjusted target object model.

[0037] Specifically, import the initial model: load the previously established initial object model into the current environment. Apply adjustment rules: define one or more sets of adjustment rules based on the information extracted from the original image and the scene requirements. These rules can be automated (based on the results predicted by the 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 the color, reflectivity and other properties of the object surface to make it more consistent with the lighting and environment 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 necessary, you can also add animation effects to the object, such as motion trajectory, deformation, etc. Real-time feedback mechanism: introduce a real-time feedback mechanism during the adjustment process, allowing users or systems to monitor the effect of the adjustment and make fine adjustments 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. Interactivity test: for dynamic or interactive objects, test whether its response is natural and smooth. Performance evaluation: measure the rendering time and memory usage of the adjusted model to ensure that it can run normally under the expected hardware conditions.

[0038] Step S150 , performing 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.

[0039] 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, the powerful parallel computing capability of the second GPU is used to decompose the rendering task into multiple small tasks for concurrent execution, such as color calculation and depth test of each pixel. Various optimization methods are used, such as LOD (Level of Detail) technology and instanced rendering, to balance quality and performance.

[0040] As an optional implementation, the GPU device also includes a third GPU; the original image analysis result is obtained after the original image data is analyzed by the first GPU using an AI algorithm; 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: image rendering of the target object model 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 fine-tuned according to the original image analysis result and the specified high-pixel requirement data to adjust the pixel height 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 the specified low-pixel requirement data.

[0041] By using the third GPU to perform preliminary rendering at a lower pixel requirement, a roughly correct visual feedback can be quickly obtained. This is very useful for application scenarios that require frequent adjustments and viewing of effects (such as real-time interactive design or game development) because it allows developers to iterate designs faster and achieve fast previews and iterations. Moreover, low-resolution rendering requires fewer computing resources, 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 resource optimization allocation. Furthermore, the second GPU makes fine adjustments to the results of the preliminary rendering based on the results of the original image analysis to ensure 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 completing all rendering work at once directly with the highest pixel requirement, this method reduces the overall amount of calculation. The preliminary rendering only needs to meet basic visualization requirements, while fine adjustments are concentrated where they are really needed, thereby reducing the overall computational complexity and time overhead, and reducing the total computational cost. This method can flexibly adjust the difference in pixel requirements between the two stages according to different application scenarios. It can prioritize speed when hardware resources are limited, and maximize the use of available resources when pursuing ultimate image quality. This improves adaptability and flexibility.

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

[0043] Exemplarily, the GPU device is set in a vehicle-mounted device, and the vehicle-mounted device corresponds to a vehicle-mounted user; Figure 2 As shown, the original image analysis result is read by the second GPU, and the initial 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 initial image rendering result to obtain the final image rendering result, including: Step S210, obtaining user operations on the vehicle-mounted device, and analyzing the composition aesthetic preference data corresponding to the vehicle-mounted user through the AI ​​system according to the user operations; 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, so as to adjust the composition style of the initial image rendering result to conform to the composition aesthetic preference data, and obtain a first image rendering result; 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.

[0044] 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.

[0045] In the embodiment of the present application, by assigning the work to two independent GPUs (the first GPU and the second GPU), computationally intensive tasks such as object recognition and model building can be performed simultaneously with scene adjustment and final rendering, which reduces the load of a single GPU and fully utilizes 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, adjusting and rendering these models according to specific scene requirements. Such division of labor can enable each GPU to focus on the most suitable task, realize intelligent allocation of tasks, and improve overall work efficiency. Furthermore, considering the specific needs of different application scenarios (such as smart car, autonomous driving, etc.), the method allows customized parameter adjustment for each case. This means that in practical applications, the rendering effect is more in line with expectations and reduces unnecessary computational overhead. For example, in some cases, very high levels of detail or complex lighting effects are not required, and rendering optimization for specific scenes is achieved. Moreover, multi-dimensional adjustments to light source angle, brightness, color, contrast, etc. are 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 properties can be modified more efficiently without having to reparse the entire scene. In addition, by using AI algorithms for object recognition and feature extraction, we can better understand the input data, thereby generating a more compact and effective 3D model, which not only helps to reduce the demand for storage space and efficiently utilize hardware resources, but also reduces the amount of data in the subsequent processing stages, thereby improving the efficiency of the GPU. Furthermore, by using the 3D engine to distribute the initial object model corresponding to each object to be rendered through the first GPU, this approach can speed up the model building process, especially when faced with a large number of complex objects, distributed computing can significantly shorten the time. In summary, this method achieves an effective improvement in the operating efficiency of the GPU by rationally planning the task process, effectively utilizing hardware resources, and specifically adapting to the requirements of different application scenarios.

[0046] The above steps are described in detail below.

[0047] In some embodiments, a Unity engine is provided in the second GPU; the above-mentioned 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, which may specifically include the following steps: The second GPU is accelerated by using the ShaderGraph and ComputeShader of the Unity engine, and multiple target matrices in the target object model are pre-calculated by using the ScriptingDefineSymbols and CustomEditor of the Unity engine based on the target object model; Based on 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, the second GPU after accelerated processing is used to render the target object model to obtain the image rendering results corresponding to the original image data under the specified scene requirement data.

[0048] By accelerating the second GPU through the ShaderGraph and ComputeShader of the Unity engine, the powerful parallel computing capabilities of the GPU can be fully utilized, thereby greatly accelerating the pre-calculation speed of multiple target matrices in the target object model. In addition, by using the ScriptingDefineSymbols and CustomEditor of the Unity engine to pre-calculate multiple target matrices in the target object model, the computational burden during real-time rendering is reduced, making the rendering process more efficient. By using the NetworkManager and MultiplayerAPI of the Unity engine for distributed computing based on multiple target matrices, the computing tasks originally undertaken by a single device are dispersed to multiple nodes for execution, which not only improves the computing speed, but also can handle more complex scenes and larger data sets. Finally, by rendering the image of the target object model on the second GPU after acceleration, high-quality image rendering results can be obtained under the specified scene requirements while maintaining efficient rendering performance. In summary, this method can greatly improve the speed and quality of image rendering, especially when processing complex scenes 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 improves the user experience, but also enhances the competitiveness of the application. By combining Unity engine features, 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.

[0049] In some embodiments, the above-mentioned acceleration processing of the second GPU through the ShaderGraph and ComputeShader of the Unity engine may specifically include the following steps: dynamically allocating resources of the second GPU through 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; adjusting 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 weights that vary with time, TaskImportance(t, x) is the importance that varies with time at position x, and TaskUrgency(t, x) is the task priority that varies with time at position x.

[0050] In the embodiment of the present application, Unity's ShaderGraph and ComputeShader are used to achieve GPU acceleration. By introducing dynamic resource allocation and task priority adjustment formulas, more intelligent and efficient GPU resource management and task scheduling can be achieved. The main beneficial effect of this method is that it can significantly improve the system's response speed and resource utilization efficiency, which is specifically manifested in the following aspects: Optimize resource allocation: The formula GPUResources(x) = γ(x) × ObjectImportance(x) dynamically allocates the resources of the second GPU according to the importance of objects at different locations. This approach ensures that resources are allocated to where they are most needed, improves rendering quality and efficiency, and avoids resource waste.

[0051] 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, thereby dynamically adjusting the task priority. This enables the system to respond more flexibly to real-time changing needs, ensure that key tasks are processed in a timely manner, and enhance the adaptability and flexibility of the system.

[0052] Enhanced user experience: By combining the above two mechanisms, it is possible to ensure that visually important elements (such as objects that the user is focusing on or the main characters in the scene) receive more computing resources, while elements that have less impact on the user experience are processed using fewer resources. This not only improves image quality, but also ensures a smooth interactive experience, especially in complex scenes or under high load.

[0053] Improve overall performance: Intelligent resource allocation and task priority management reduce unnecessary computing overhead, allowing the GPU to work in the best condition at all times, thereby improving the performance and stability of the entire system.

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

[0055] In some embodiments, the above-mentioned pre-calculation of multiple target matrices in the target object model using ScriptingDefineSymbols and CustomEditor of the Unity engine based on the target object model may specifically include the following steps: 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, use the Unity engine's ScriptingDefineSymbols and CustomEditor to precalculate multiple target matrices in the target object model using the following formula according to the precalculation frequency: 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.

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

[0057] Dynamically adapt to scene changes: Through the formula PrecomputeFrequency(t) = α(t) ×SceneChangeRate(t) + β(t), this method can dynamically adjust the precompute frequency according to the rate of change of the scene. This means that when the scene changes rapidly, the system will increase the precompute frequency to maintain responsiveness; when the scene is relatively stable, the precompute frequency will be reduced to save resources. This flexibility enables the system to use computing resources more efficiently.

[0058] Optimize the priority of precomputed tasks: Use the formula 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 get higher priority, thereby improving the quality of the end-user experience while ensuring that urgent tasks are not delayed.

[0059] Improve development efficiency and flexibility: With the Unity engine's ScriptingDefineSymbols and CustomEditor features, developers can automatically perform complex target matrix precalculations based on precalculation frequency. This approach not only simplifies the development process, but also allows developers to easily customize precalculation strategies to adapt to different project requirements and technical limitations.

[0060] Enhance runtime performance: Through the above mechanism, the background processing process can be optimized and unnecessary calculations can be reduced without affecting the user experience, thereby reducing the CPU and GPU load and improving the overall operating efficiency.

[0061] In summary, this approach achieves efficient resource management and task scheduling optimization, allowing developers to maximize the use of available resources while ensuring high-quality output, providing a smooth and responsive application experience. In addition, this approach also enhances development flexibility and efficiency, providing strong support for the creation of complex interactive content.

[0062] In some embodiments, the above-mentioned distributed calculation of multiple target matrices using the NetworkManager and MultiplayerAPI of the Unity engine based on multiple target matrices to obtain distributed calculation results may specifically include the following steps: The dynamic adjustment task assignment strategy 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; 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 change over time, TaskImportance(t,x) is the importance of the target matrix at position x that changes over time, and TaskUrgency(t,x) is the task priority of the target matrix at position x that changes over time. Based on multiple target matrices, the dynamically allocated computing resources in the Unity engine are used to dynamically adjust the task allocation strategy and perform distributed computing on multiple target matrices according to the task allocation priority to obtain distributed computing results.

[0063] By combining dynamic task allocation strategies, intelligent allocation of computing resources and priority adjustment, it aims to optimize the processing efficiency of multiple target matrices in a distributed computing environment, achieves efficient distributed computing resource utilization and task scheduling, and thus significantly improves system performance and response speed.

[0064] Intelligent task allocation: Through the formula TaskAssignment(t) = arg max(NetworkQuality_i(t)× TaskPriority_i(t)), each task is assigned to the node with the best network quality and the best task priority requirements. This not only maximizes the execution efficiency of a single task, but also ensures load balancing of the entire system.

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

[0066] Dynamic priority adjustment: The formula TaskPriority(t, x) = δ(t) × TaskImportance(t,x) + ε(t) × TaskUrgency(t, x) is used to adjust the task priority in real time as time passes and the task importance and urgency change. This allows critical and urgent tasks to be processed in a timely manner, enhancing the flexibility and responsiveness of the system.

[0067] Improve distributed computing efficiency: Based on the dynamically allocated computing resources in the Unity engine, distributed computing of multiple target matrices according to the above strategy can effectively reduce computing delays and increase data processing speed. At the same time, since the tasks are reasonably allocated to the most suitable computing nodes, unnecessary data transmission overhead is reduced, further improving the overall computing efficiency.

[0068] In summary, this method achieves efficient distributed computing resource management and task scheduling optimization, which can maximize the use of available resources while ensuring efficient task completion, and provide fast and reliable computing services. In addition, this method also enhances the adaptability and scalability of the system, providing strong support for the creation of complex large-scale distributed computing applications. In this way, developers can ensure high-performance operation of the system in complex environments while simplifying the development and management process.

[0069] Figure 3 A schematic diagram of the structure of a Unity image rendering device based on the YTS system AI algorithm is provided. The device can be applied to a GPU device, wherein the GPU device includes a first GPU and a second GPU. Figure 3 As shown, the Unity image rendering device 300 based on the YTS system AI algorithm includes: An acquisition module 301 is used to acquire the original image data to be processed; The recognition module 302 is used to analyze the original image data by using an AI algorithm through the first GPU and perform object recognition on the original image data to obtain a plurality of objects to be rendered in the original image data; An establishing module 303 is used 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 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 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; and the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color, and contrast; The rendering module 305 is used 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.

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

[0071] An electronic device provided in an embodiment of the present application is Figure 4 As shown, the electronic device 400 includes a processor 402 and a memory 401, wherein the memory stores a computer program that can be run on the processor, and the processor implements the steps of the method provided in the above embodiment when executing the computer program.

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

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

[0074] The bus 403 may be an ISA bus, a PCI bus, or an EISA bus, etc. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 4 Only one bidirectional arrow is used in the diagram, but this does not mean that there is only one bus or only one type of bus.

[0075] Among them, the memory 401 is used to store programs, and the processor 402 executes the program after receiving the execution instruction. 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.

[0076] The processor 402 may be an integrated circuit chip with signal processing capabilities. In the implementation process, each step of the above method can be completed by the hardware integrated logic circuit or software instructions in the processor 402. The above processor 402 can be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc.; it can also be a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components. The methods, steps and logic block diagrams disclosed in the embodiments of the present application can be implemented or executed. The general processor can be a microprocessor or the processor can also be any conventional processor, etc. The steps of the method disclosed in the embodiments of the present application can be directly embodied as a hardware decoding processor to execute, or the hardware and software modules in the decoding processor are combined to execute. The software module may be located in a storage medium mature 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. The storage medium is located in the memory 401, and the processor 402 reads the information in the memory 401 and completes the steps of the above method in combination with its hardware.

[0077] 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, which stores computer-executable instructions. When the computer-executable instructions are called and executed by the processor, the computer-executable instructions prompt the processor to execute the steps of the above-mentioned Unity image rendering method based on the YTS system AI algorithm.

[0078] The Unity image rendering device based on the YTS system AI algorithm provided in the embodiment of the present application can be specific hardware on the device or software or firmware installed on the device. The implementation principle and technical effects of the device provided in the embodiment of the present application are the same as those of the aforementioned method embodiment. For the sake of brief description, for matters not mentioned in the device embodiment, reference can be made to the corresponding contents in the aforementioned method embodiment. Technical personnel in the relevant field can clearly understand that for the convenience and conciseness of the description, the specific working processes of the systems, devices and units described above can all refer to the corresponding processes in the aforementioned method embodiments, and will not be repeated here.

[0079] 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 schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation. For 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 mutual coupling or direct coupling or communication connection shown or discussed can be through some communication interfaces, and the indirect coupling or communication connection of the devices or units can be electrical, mechanical or other forms.

[0080] For another example, the flowchart and block diagram in the accompanying drawings show the possible architecture, function and operation of the device, method and computer program product according to multiple embodiments of the present application. In this regard, each box in the flowchart or block diagram can represent a module, a program segment or a part of the code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order from the order marked in the accompanying drawings. For example, two consecutive boxes can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or the flowchart, and the combination of the boxes in the block diagram and / or the flowchart can be implemented with a dedicated hardware-based system that performs a specified function or action, or can be implemented with a combination of dedicated hardware and computer instructions.

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

[0082] In addition, each functional unit in the embodiments provided in the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0083] If the 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 the present application can be essentially or partly embodied in the form of a software product that contributes to the prior art. The computer software product is stored in a storage medium, including several instructions to enable a computer device (which can be a personal computer, server, or network device, etc.) to perform all or part of the steps of the Unity image rendering method based on the YTS system AI algorithm described in each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (Read-Only Memory, referred to as ROM), random access memory (Random Access Memory, referred to as RAM), disk or optical disk and other media that can store program codes.

[0084] It should be noted that similar numbers and letters represent similar items in the following figures. Therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures. In addition, the terms "first", "second", "third", etc. are only used to distinguish the description and are not to be understood as indicating or implying relative importance.

[0085] Finally, it should be noted that the above-described embodiments are only specific implementation methods of the present application, which are used to illustrate the technical solution of the present application, rather than to limit it. The protection scope of the present application is not limited thereto. Although the present application is described in detail with reference to the aforementioned embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solution recorded in the aforementioned embodiments within the technical scope disclosed in the present application, or can easily think of changes, or make equivalent replacements for some of the technical features therein; 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 embodiment of the present application. They should all be included in the protection scope of the present application. Therefore, the protection scope of the present application shall be based on 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; and the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color, and contrast; 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.

2. The method according to claim 1, characterized in that The GPU device further includes a third GPU; the first GPU analyzes the original image data using an AI algorithm to obtain an original image analysis result; the second GPU performs image rendering 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: Performing image rendering on the target object model according to the specified low-pixel requirement data by the third GPU 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 original image analysis result and the specified high pixel requirement data to adjust the pixel height 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 the specified low pixel requirement data.

3. The method according to claim 2, 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.

4. 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.

5. 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.

6. The method according to claim 5, 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.

7. The method according to claim 5, 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.

8. The method according to claim 5, 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.

9. 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, autonomous 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; and the adjustment dimension of the multi-dimensional adjustment includes at least one of light source angle, brightness, color, and contrast; A rendering module is used 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.

10. 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 8.

Images