Cloud edge end collaborative three-dimensional model rendering method and related device

Abstract

The application is suitable for the technical field of cloud edge cooperation, and provides a three-dimensional model rendering method for cloud edge cooperation and related equipment. A local subtree traversal is performed on a detail level tree of a current frame according to a search result of a previous frame on a cloud end, and a detail level segmentation set is obtained. A geographical partition decomposition is performed according to the spatial positions and projection sizes of each Gaussian ellipsoid in the detail level segmentation set, and a plurality of regional rendering subtasks are obtained. A perspective projection transformation and rasterization processing are performed on the Gaussian ellipsoid on an edge end, and projection and depth feature extraction are performed on a dynamic point cloud, so that a regional rendering result and depth feature data are obtained. Pixel-level fusion is performed on the regional rendering results of a plurality of edge ends according to the depth feature data on a terminal, and a three-dimensional model rendering image is obtained. The three-dimensional scene rendering task is processed in layers through the cloud edge cooperation architecture, the bandwidth demand between the cloud end and the terminal is reduced, and the image quality of the multi-edge node cooperative rendering is guaranteed through the depth feature guidance.

Description

Technical Field

[0001] This invention relates to the field of cloud-edge collaboration technology, and in particular to a three-dimensional model rendering method and related equipment for cloud-edge-device collaboration. Background Technology

[0002] With the rapid development of digital twin technology, the demand for real-time rendering of large-scale 3D scenes at the city and park levels is increasing. Existing 3D model rendering solutions typically employ a single-level rendering architecture, where all rendering tasks are executed centrally in the cloud or on the terminal. However, the data volume of large-scale 3D scenes can reach tens of gigabytes. When dealing with ultra-large-scale scenes, a single-level architecture requires the cloud to transmit the complete rendering results to the terminal as a video stream, resulting in extremely high bandwidth requirements between the cloud and the terminal. In real-world environments with limited network bandwidth, it is difficult to guarantee the real-time performance of rendering.

[0003] Currently, although some solutions attempt to introduce edge nodes to share the rendering load, existing edge collaborative rendering solutions lack a detailed level management mechanism for large-scale 3D scenes, and the task allocation between edge nodes also lacks an effective load balancing strategy, resulting in occlusion errors when the rendering results of each edge node are merged at the terminal, which cannot guarantee the image quality of multi-node collaborative rendering. Summary of the Invention

[0004] This invention provides a cloud-edge-device collaborative 3D model rendering method and related equipment to solve the technical problems of excessive bandwidth requirements between the cloud and the terminal and improper handling of occlusion relationships during collaborative rendering of multiple edge nodes, which lead to image quality degradation in existing 3D model rendering solutions.

[0005] In a first aspect, embodiments of this application provide a cloud-edge-device collaborative 3D model rendering method, including: In the cloud, a time-aware search is performed on the detail hierarchy tree of the 3D scene. Based on the search results of the previous frame, a local subtree traversal is performed on the detail hierarchy tree of the current frame to obtain the detail hierarchy segmentation set corresponding to the current frame. Based on the spatial location and projection size of each Gaussian ellipsoid in the detail level segmentation set, the detail level segmentation set is geographically partitioned to obtain multiple regional rendering subtasks; At the edge, Gaussian ellipsoid data and dynamic point cloud data of the corresponding region are received according to the multiple region rendering sub-tasks. The received Gaussian ellipsoid is subjected to perspective projection transformation and rasterization processing. The received dynamic point cloud is subjected to projection and depth feature extraction to obtain the region rendering result and the corresponding depth feature data. The terminal performs pixel-level fusion based on depth values ​​on the region rendering results from multiple edge ends according to the depth feature data to obtain a three-dimensional model rendering image.

[0006] Secondly, embodiments of this application provide a cloud-edge-device collaborative 3D model rendering device, comprising: The temporal search module is used to perform time-aware searches on the detail hierarchy tree of a 3D scene in the cloud. Based on the search results of the previous frame, it performs local subtree traversal on the detail hierarchy tree of the current frame to obtain the detail hierarchy segmentation set corresponding to the current frame. The partitioning module is used to perform geographic partitioning of the detail level segmentation set according to the spatial position and projection size of each Gaussian ellipsoid in the detail level segmentation set, and obtain multiple regional rendering subtasks. The edge rendering module is used to receive Gaussian ellipsoid data and dynamic point cloud data of the corresponding region at the edge according to the multiple region rendering sub-tasks, perform perspective projection transformation and rasterization processing on the received Gaussian ellipsoid, and perform projection and depth feature extraction on the received dynamic point cloud to obtain the region rendering result and the corresponding depth feature data. The depth fusion module is used to perform pixel-level fusion based on depth values ​​on the region rendering results from multiple edge ends according to the depth feature data at the terminal to obtain a three-dimensional model rendering image.

[0007] Thirdly, embodiments of this application provide a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the steps of the above-described cloud-edge-device collaborative 3D model rendering method.

[0008] Fourthly, embodiments of this application provide a readable storage medium storing a computer program that, when executed by a processor, implements the steps of the aforementioned cloud-edge-device collaborative 3D model rendering method.

[0009] Fifthly, embodiments of this application provide a computer program product, which includes a computer program that, when executed by a processor, enables the implementation of the above-described cloud-edge-device collaborative 3D model rendering method.

[0010] In one solution provided by the aforementioned cloud-edge-device collaborative 3D model rendering method, apparatus, device, medium, and program products, a time-aware search is performed on the detail hierarchy tree of the 3D scene in the cloud. Based on the search results of the previous frame, a local subtree traversal is performed on the detail hierarchy tree of the current frame to obtain a detail hierarchy segmentation set. The detail hierarchy segmentation set is then geographically partitioned based on the spatial position and projection size of each Gaussian ellipsoid in the detail hierarchy segmentation set, resulting in multiple region rendering subtasks. At the edge, the received Gaussian ellipsoids are subjected to perspective projection transformation and rasterization processing according to the region rendering subtasks, and the received dynamic point cloud is projected and depth features are extracted to obtain region rendering results and depth feature data. At the terminal, the region rendering results from multiple edge terminals are fused pixel-level based on depth values ​​according to the depth feature data to obtain a 3D model rendering image. This invention uses a three-level cloud-edge-device collaborative architecture to process the rendering tasks of large-scale 3D scenes in layers, reducing the bandwidth requirements between the cloud and the terminal, and ensuring the image quality of multi-edge node collaborative rendering through pixel-level fusion guided by depth features. Attached Figure Description

[0011] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the description of the embodiments of the present invention will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0012] Figure 1 This is a schematic diagram of a cloud-edge-device collaborative 3D model rendering system according to an embodiment of the present invention; Figure 2 This is a flowchart illustrating a cloud-edge-device collaborative 3D model rendering method in one embodiment of the present invention; Figure 3 yes Figure 2 A schematic diagram of the implementation process of step S10; Figure 4 yes Figure 2 A schematic diagram of the implementation process of step S20; Figure 5 This is a schematic diagram of a cloud-edge-device collaborative 3D model rendering device in one embodiment of the present invention; Figure 6 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention. Detailed Implementation

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

[0014] It should be understood that, when used in this specification and the appended claims, the term "comprising" indicates the presence of the described features, integrals, steps, operations, elements, and / or components, but does not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components, and / or collections thereof. It should also be understood that, as used in this specification and the appended claims, the term "and / or" refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0015] Furthermore, in the description of this invention and the appended claims, the terms "first," "second," "third," etc., are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0016] References to "one embodiment" or "some embodiments" as described in this specification mean that one or more embodiments of the invention include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0017] It should be understood that the sequence number of each step in the following embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0018] To illustrate the technical solution of the present invention, specific embodiments are described below.

[0019] To address the problems mentioned above in the background technology, this application proposes a cloud-edge-device collaborative 3D model rendering method, apparatus, device, medium, and program product. The cloud-edge-device collaborative 3D model rendering method provided by this invention can be applied to applications such as... Figure 1 The cloud-edge-device collaborative 3D model rendering system shown includes a client and a server.

[0020] In one embodiment, such as Figure 2 As shown, a cloud-edge-device collaborative 3D model rendering method is provided, which is then applied to... Figure 1 Taking a cloud-edge-device collaborative 3D model rendering system as an example, the following steps are included: S10: Perform a time-aware search on the detail hierarchy tree of the 3D scene in the cloud, and perform a local subtree traversal on the detail hierarchy tree of the current frame based on the search results of the previous frame to obtain the detail hierarchy segmentation set corresponding to the current frame. S20: Based on the spatial location and projection size of each Gaussian ellipsoid in the detail level segmentation set, the detail level segmentation set is geographically partitioned to obtain multiple regional rendering subtasks; S30: At the edge end, according to the multiple region rendering sub-tasks, the Gaussian ellipsoid data and dynamic point cloud data of the corresponding region are received, the received Gaussian ellipsoid is subjected to perspective projection transformation and rasterization processing, the received dynamic point cloud is subjected to projection and depth feature extraction, and the region rendering result and the corresponding depth feature data are obtained. S40: At the terminal, pixel-level fusion based on depth values ​​is performed on the region rendering results from multiple edge ends according to the depth feature data to obtain a three-dimensional model rendering image.

[0021] In this embodiment, all Gaussian ellipsoids in the 3D scene are organized and managed in the form of a hierarchy of details tree. Each node in the hierarchy of details tree corresponds to a Gaussian ellipsoid, and child nodes represent a more refined representation of the region represented by the parent node. For large-scale 3D scenes at the city level, the number of nodes in the hierarchy of details tree can reach tens of millions. If a complete traversal is performed starting from the root node in each frame, the computational overhead is extremely high.

[0022] Based on the above description, in this embodiment, when performing a time-aware search, the cloud does not perform a full traversal of the level-of-detail tree. Instead, it utilizes the temporal coherence of scene content between adjacent frames, using the search results of the previous frame as the starting point for the search in the current frame. Specifically, the search results of the previous frame record the positions of each Gaussian ellipsoid node used in the rendering of the previous frame within the level-of-detail tree. These nodes collectively constitute the level-of-detail segmentation set of the previous frame, which is a node cutting surface in the level-of-detail tree that separates upper-level nodes from lower-level nodes.

[0023] Based on this, the cloud can locate the nodes in the detail level tree corresponding to the segmentation set of the previous frame according to the search results of the previous frame, and determine the range of candidate subtrees that need to be retraced in the current frame according to the parent-child relationship of each node in the detail level tree. Then, according to the camera parameters of the current frame, the cloud calculates the projection size of each node in the candidate subtree on the image plane, expands the nodes with projection sizes greater than the preset detail level threshold to their child nodes and continues the search, and directly includes the nodes with projection sizes less than or equal to the preset detail level threshold into the detail level segmentation set of the current frame. This process is repeated until the candidate subtree search is completed, and the detail level segmentation set corresponding to the current frame is obtained.

[0024] For example, during the rendering of a frame, if the camera's view is directed towards a city block, the subtree nodes corresponding to that block have a larger projected size and need to be expanded to more refined leaf nodes. Conversely, the subtree nodes corresponding to distant buildings have smaller projected sizes and can be rendered directly as coarser-grained nodes. In the next frame, if the camera's view doesn't change significantly, the cloud can start directly from the segment set of the previous frame and only perform local updates on the few subtrees whose projected sizes have changed due to the view change, without needing to retrace the entire tree, thus significantly reducing the amount of search computation.

[0025] In this embodiment, the level-of-details segmentation set contains all the Gaussian ellipsoids required for rendering the current frame. However, these Gaussian ellipsoids are not uniformly distributed in 3D space, and directly assigning them as a whole to a single edge node would result in an excessive computational load on that node. Therefore, in this embodiment, after completing the level-of-details search, the cloud further performs geographical partitioning decomposition on the level-of-details segmentation set, breaking it down into multiple parallel region rendering subtasks.

[0026] Specifically, the cloud performs spatial clustering on all Gaussian ellipsoids based on their 3D spatial coordinates within the detail-level segmentation set. Spatially adjacent Gaussian ellipsoids are assigned to the same geographic region, resulting in multiple initial geographic regions. Then, the number of Gaussian ellipsoids within each initial geographic region is counted, and the projected size of each Gaussian ellipsoid on the current frame image plane is calculated. The product of the number of Gaussian ellipsoids and the projected size is used as the rendering load value for that region. Based on this, and according to the rendering load values ​​of each initial geographic region and the available computing resources of each edge node, multiple initial geographic regions with a rendering load value difference less than a preset first threshold are assigned to the same edge node, resulting in multiple region rendering subtasks.

[0027] It's important to note that the rendering load value considers both the number of Gaussian ellipsoids and their projected size. This is because a Gaussian ellipsoid with a larger projected size covers more pixels during rasterization, resulting in greater computational overhead. Measuring the load solely by the number of Gaussian ellipsoids would underestimate this overhead. Therefore, the product of these two factors more accurately reflects the actual rendering pressure on each partition, leading to a more balanced task distribution across edge nodes.

[0028] In this embodiment, after receiving the region rendering subtask from the cloud, each edge node obtains the Gaussian ellipsoid data of the corresponding region from the cloud and the dynamic point cloud data of the corresponding region from the data stream of the locally accessed IoT device. The edge node processes the two types of data separately and finally outputs the region rendering result and depth feature data.

[0029] For processing Gaussian ellipsoid data, the edge processing department performs a two-dimensional projection transformation on the three-dimensional covariance matrix of each Gaussian ellipsoid based on the camera parameters of the current frame, obtaining the two-dimensional Gaussian distribution parameters and corresponding depth values ​​of each Gaussian ellipsoid on the image plane. Then, the two-dimensional Gaussian distributions are sorted from near to far according to their depth values, and transparency blending is performed on each distribution in the sorted order to obtain the region rendering result of the static scene.

[0030] For processing dynamic point cloud data, the edge end projects the dynamic point cloud to generate a depth map, and then scans the depth map according to the image rows. Continuous pixels with similar depth values ​​are merged into depth feature segments, and the start position, end position and average depth value of each depth feature segment are recorded to obtain depth feature data.

[0031] Based on the above description, the edge device transmits the region rendering results of the static scene along with the depth feature data to the terminal. It should be noted that in this embodiment, the depth feature data is represented in the form of compressed depth feature segments. Compared to directly transmitting the complete depth map, the data volume is significantly reduced, which helps to reduce the bandwidth usage from the edge device to the terminal.

[0032] In this embodiment, after receiving the region rendering results and depth feature data from multiple edge nodes, the terminal first parses the depth feature data transmitted from each edge node, and fills the corresponding average depth value into the corresponding pixel position of the image plane according to the start position, end position and average depth value of each depth feature segment, so as to obtain the depth distribution map corresponding to each edge node.

[0033] Then, the terminal compares the depth value of each pixel in the depth distribution map corresponding to each edge, selects the edge with the smallest depth value as the source edge of that pixel, and obtains the mapping relationship from pixel to source edge. Finally, based on this mapping relationship, the color value of each pixel is extracted from the region rendering result of the corresponding source edge to obtain the 3D model rendering image.

[0034] For example, edge rendering A is responsible for rendering the buildings in a certain block, while edge rendering B is responsible for rendering the dynamic vehicles in that block. There is some overlap between the two on the image plane. Within this overlap, if a vehicle is in front of a building, the depth value of the pixel corresponding to the vehicle is less than the depth value of the pixel corresponding to the building. The rendering terminal uses depth comparison to select the rendering result from edge rendering B to fill this pixel, thus ensuring the correctness of the occlusion relationship and obtaining a visually coherent 3D model rendering image.

[0035] In one embodiment, such as Figure 3 As shown, step S10 specifically includes the following steps: S11: Locate each node in the detail hierarchy tree of the 3D scene in the cloud that corresponds to the detail hierarchy segmentation set of the previous frame, and determine the candidate traversal subtree set based on the parent-child relationship of each node in the detail hierarchy tree. S12: Based on the camera parameters of the current frame, perform projection transformation on the root nodes of each subtree in the candidate traversal subtree set, calculate the projection size of each root node on the image plane, add the child nodes of the root nodes whose projection size is greater than the preset detail level threshold to the search queue, and add the root nodes whose projection size is less than or equal to the preset detail level threshold to the detail level segmentation set of the current frame, thus obtaining the search queue and a partial detail level segmentation set. S13: Perform projection transformation and projection size calculation on each node in the search queue in sequence. Update the search queue and the detail level segmentation set according to the comparison result between the projection size and the preset detail level threshold until the search queue is empty, and obtain the detail level segmentation set corresponding to the current frame.

[0036] In this embodiment, the level-of-detail tree organizes all Gaussian ellipsoids in the scene using an irregular tree structure. Each node in the tree corresponds to a Gaussian ellipsoid. Nodes at higher levels in the tree represent a coarse-grained representation of the corresponding region, while nodes at lower levels represent a fine-grained representation. The level-of-detail segmentation set of the previous frame records the positions of each node selected during the rendering of the previous frame within the level-of-detail tree. These nodes together form a dividing line that runs through the level-of-detail tree, separating the upper-level nodes from the lower-level nodes.

[0037] Based on the above explanation, when processing the current frame, the cloud first locates each node in the detail level segmentation set of the previous frame in the detail level tree. Since the changes in scene content between adjacent frames are mainly concentrated in local areas where the camera viewpoint shifts, most nodes are still applicable in the current frame, and only a few nodes need to be re-evaluated due to the change in viewpoint. Therefore, the cloud takes each node in the previous frame's segmentation set as a starting point, and according to the parent-child relationship of each node in the detail level tree, includes the parent and child nodes of each node in the candidate range, obtaining a candidate traversal subtree set.

[0038] It's important to note that the candidate traversal subtree set only includes local subtrees directly related to the nodes in the previous frame's segmentation set, rather than all nodes in the level-of-detail tree. This is the key difference between time-aware search and full tree traversal. For example, for a city-level level-of-detail tree containing tens of millions of nodes, the number of nodes in the candidate traversal subtree set typically only accounts for a few percent of the total number of nodes in the entire tree, thus significantly narrowing the search scope to a local area.

[0039] In this embodiment, the cloud processes the root nodes of each subtree in the candidate traversal subtree set sequentially. Specifically, for each root node, the cloud projects the Gaussian ellipsoid corresponding to the node from three-dimensional space to the image plane based on the camera intrinsic and extrinsic parameter matrices of the current frame, and calculates its projection size on the image plane. The size of the projection size reflects the degree of contribution of the Gaussian ellipsoid to the final rendered image from the current viewpoint.

[0040] Then, the cloud compares the calculated projection size with a preset level of detail threshold. If the projection size is greater than the preset level of detail threshold, it means that the area represented by the node is not detailed enough in the current viewpoint and needs to be further expanded to its child nodes for more refined representation. Therefore, all child nodes of the root node are added to the search queue. If the projection size is less than or equal to the preset level of detail threshold, it means that the level of detail of the node already meets the rendering requirements of the current viewpoint, and the node is directly included in the level of detail segmentation set of the current frame. After processing all root nodes in the candidate traversal subtree set, the search queue and a partial level of detail segmentation set are obtained.

[0041] For example, for buildings that are close to the camera directly in front of it, the projection size of the corresponding node is large, exceeding the preset detail level threshold, and needs to be expanded to a more refined sub-node; for distant buildings at the edge of the camera's field of view, the projection size of the corresponding node is already small, and can be directly used for rendering with the current node.

[0042] In this embodiment, after processing S12, the search queue contains nodes that need further expansion. The cloud retrieves each node from the search queue in sequence, performs projection transformation and projection size calculation on each node in the same manner as in S12, and decides whether to continue expansion based on the comparison result between the projection size and the preset level of detail threshold.

[0043] Specifically, if the projected size of the extracted node is still greater than the preset level of detail threshold, then the node's child nodes are added to the search queue; if the projected size of the extracted node is less than or equal to the preset level of detail threshold, then the node is added to the level of detail segmentation set, and its child nodes are no longer expanded. This process is repeated, with each node being extracted from the search queue for judgment, and the search queue and level of detail segmentation set being updated based on the judgment result, until there are no more nodes to be processed in the search queue, thus obtaining the level of detail segmentation set corresponding to the current frame.

[0044] Based on this, all nodes in the detail level segmentation set satisfy the condition that the projected size is less than or equal to the preset detail level threshold, meaning that the Gaussian ellipsoids represented by these nodes have reached the rendering requirements in terms of detail from the current viewpoint. It should be noted that the search queue is managed using a first-in, first-out (FIFO) queue structure, ensuring that nodes at each level are processed sequentially from shallow to deep, avoiding repeated access to the same subtree.

[0045] In one embodiment, such as Figure 4 As shown, step S20 specifically includes the following steps: S21: Based on the three-dimensional spatial coordinates of each Gaussian ellipsoid in the detailed level segmentation set, perform spatial clustering to divide Gaussian ellipsoids with adjacent spatial locations into the same geographical partition, thus obtaining multiple initial geographical partitions; S22: Calculate the number of Gaussian ellipsoids and the projected size of each Gaussian ellipsoid in each initial geographic region, and calculate the rendering load value of each initial geographic region based on the product of the number of Gaussian ellipsoids and the projected size. S23: Based on the rendering load value of each initial geographic partition and the available computing resources of the edge node, assign multiple initial geographic partitions whose rendering load value difference is less than a preset first threshold to the same edge node to obtain multiple regional rendering subtasks.

[0046] In this embodiment, the detail level segmentation set contains all the Gaussian ellipsoids required for rendering the current frame. These Gaussian ellipsoids are distributed in different geographical locations in three-dimensional space. For example, in a city digital twin scene, the building complexes, roads, squares, and other areas each correspond to different sets of Gaussian ellipsoids in different spatial locations. In order to reasonably distribute the rendering task to multiple edge nodes for parallel processing, these Gaussian ellipsoids need to be grouped according to their spatial locations first.

[0047] Specifically, the cloud extracts the 3D spatial coordinates of each Gaussian ellipsoid from the detailed hierarchical segmentation set. Based on these spatial coordinates, all Gaussian ellipsoids are spatially clustered, grouping adjacent Gaussian ellipsoids in 3D space into the same geographic region. During the clustering process, Gaussian ellipsoids within the same geographic region are spatially continuous, while different geographic regions have certain spatial intervals, resulting in multiple initial geographic regions.

[0048] It should be noted that the granularity of the initial geographic partitioning is related to the number of edge nodes. The number of partitions should not be less than the number of available edge nodes to ensure that each edge node undertakes the rendering task of at least one partition. For example, in a digital twin scene of a city block, the scene can be divided into several initial geographic partitions according to the block boundaries. The Gaussian ellipsoid within each partition corresponds to the buildings and ground elements within that block.

[0049] In this embodiment, the number of Gaussian ellipsoids contained in each initial geographic partition and the projected size of each Gaussian ellipsoid jointly determine the rendering overhead at the edge of that partition. The number of Gaussian ellipsoids reflects the data scale of the partition, while the projected size reflects the pixel range that each Gaussian ellipsoid needs to cover during the rasterization stage. A larger projected size means that the Gaussian ellipsoid needs to process more pixels during rasterization, resulting in a higher computational overhead.

[0050] Based on the above explanation, the cloud calculates the total number of Gaussian ellipsoids contained in each initial geographic partition, and calculates the cumulative value of the projected dimensions of all Gaussian ellipsoids within that partition, based on the projected dimensions of each Gaussian ellipsoid calculated in S12. The product of the number of Gaussian ellipsoids and the cumulative projected dimensions is then used as the rendering load value for that initial geographic partition. A higher rendering load value indicates that the partition requires more computational resources when performing rendering at the edge.

[0051] For example, if an initial geographic region is located directly in front of the camera's viewpoint, the Gaussian ellipsoid projection size it contains is generally large. Even if the number of Gaussian ellipsoids within this region is similar to that of other regions, its rendering load will be significantly higher than that of regions located at the edge of the viewpoint. By introducing the projection size as a reference for load estimation, we can avoid underestimating the rendering overhead of densely populated nearby areas when measuring load solely by the number of Gaussian ellipsoids.

[0052] In this embodiment, after calculating the rendering load value for each initial geographic partition, the cloud, based on the available computing resources of each edge node, rationally allocates multiple initial geographic partitions to each edge node. Available computing resources can be obtained through the GPU remaining computing power information periodically reported by each edge node.

[0053] Specifically, the cloud compares the rendering load values ​​of each initial geographic partition pairwise. Multiple initial geographic partitions whose rendering load differences are less than a preset first threshold are grouped together and assigned to the same edge node for processing. During the allocation process, it is also necessary to ensure that the sum of the rendering load values ​​of multiple initial geographic partitions assigned to the same edge node does not exceed the available computing resources of that node, to avoid resource bottlenecks caused by a single node handling too many rendering tasks. Through this allocation process, each edge node corresponds to rendering tasks for one or more initial geographic partitions, resulting in multiple regional rendering subtasks.

[0054] Based on this, after receiving the corresponding region rendering subtask, each edge node pulls the Gaussian ellipsoid data contained in the subtask from the cloud and combines it with the locally accessed dynamic point cloud data to execute the subsequent region rendering process. It should be noted that the value of the preset first threshold determines the degree of load balance among the partitions within the same edge node. This threshold can be adjusted according to the differences in computing resources of edge nodes in the actual deployment environment, and no specific limitation is made thereto.

[0055] In one embodiment, step S23 specifically includes the following steps: The network link bandwidth between the cloud and each edge node, the GPU load of each edge node, and the scene complexity of the current frame's 3D scene are collected to obtain network bandwidth, GPU load, and scene complexity values. The available computing resources of each edge node are weighted and adjusted based on the network bandwidth value, GPU load value, and scene complexity value to obtain the dynamic available resource value of each edge node. Based on the rendering load value of each initial geographic partition and the dynamic available resource value of each edge node, multiple initial geographic partitions whose difference in rendering load value is less than a preset first threshold and whose sum of rendering load value does not exceed the dynamic available resource value of the corresponding edge node are assigned to the same edge node, resulting in multiple regional rendering subtasks.

[0056] In real-world deployment environments, the available computing resources of edge nodes are not fixed. Network link conditions, the node's own GPU load, and the complexity of the current scenario all affect the task allocation results. Therefore, this embodiment introduces real-time collection of three types of runtime metrics in the task allocation stage of S23 to dynamically adjust the available computing resources of each edge node before executing the allocation decision.

[0057] The three types of indicators are collected in the following ways: the network bandwidth value is obtained by detecting the link between the cloud and each edge node, reflecting the transmission capacity of data transmission at the current moment; the GPU load value is periodically reported by each edge node, reflecting the current computing pressure of the node; and the scene complexity value is obtained by statistically analyzing the total number of Gaussian ellipsoids and the average projected size in the detail level segmentation set of the current frame, reflecting the overall scale of the rendering task of this frame.

[0058] After obtaining the above three types of indicators, the cloud uses the original available computing resources of each edge node as a basis, and adjusts them according to the network bandwidth value, GPU load value, and scene complexity value to obtain the dynamic available resource value of each edge node. Among them, the dynamic available resource value of the node with insufficient network bandwidth will be reduced accordingly to reduce the amount of rendering data allocated to the node; the dynamic available resource value of the node with high GPU load will also be reduced to avoid rendering delay caused by task backlog; when the overall scene complexity is high, the dynamic available resource value of each node will be tightened as a whole, so as to promote a more distributed and balanced allocation result.

[0059] Then, the cloud performs allocation based on the rendering load values ​​of each initial geographic partition and the corrected dynamic available resource values ​​of each edge node. Allocation requires two conditions to be met simultaneously: first, the difference in rendering load values ​​between multiple initial geographic partitions allocated to the same edge node must be less than a preset first threshold; second, the sum of the rendering load values ​​of these partitions must not exceed the dynamic available resource value of the corresponding edge node. Multiple initial geographic partitions that meet the above two conditions are merged into a single region rendering subtask, allocated to the corresponding edge node for execution, ultimately resulting in multiple region rendering subtasks.

[0060] For example, if a certain edge node has a high GPU load at the current moment, its dynamic available resource value will be lower than the initial value after correction. When allocating resources, the cloud will reduce the number of initial geographical partitions allocated to that node and transfer some partitions to other nodes with lower loads, thereby maintaining the rationality of task allocation for each node under dynamic changes in network and computing power conditions.

[0061] In one embodiment, step S30 specifically includes the following steps: Based on the camera parameters of the current frame, a two-dimensional projection transformation is performed on the three-dimensional covariance matrix of each Gaussian ellipsoid to obtain the two-dimensional Gaussian distribution parameters and corresponding depth values ​​of each Gaussian ellipsoid on the image plane. The two-dimensional Gaussian distribution parameters are sorted from near to far according to their depth values. The transparency of each two-dimensional Gaussian distribution parameter is then calculated sequentially according to the sorted order to obtain the region rendering result of the static scene. The received dynamic point cloud data is projected to generate a depth map. The depth map is scanned according to the image rows. Continuous pixel segments with a depth value difference less than a preset second threshold are merged into depth feature segments. The start position, end position and average depth value of each depth feature segment are recorded to obtain depth feature data. The region rendering result of the static scene and the depth feature data are transmitted to the terminal as region rendering result and corresponding depth feature data.

[0062] In this embodiment, the edge device processes the received Gaussian ellipsoid data and dynamic point cloud data in parallel through two processing lines. The two lines ultimately output the region rendering results of the static scene and the depth feature data of the dynamic object, respectively, and then package and transmit them to the terminal.

[0063] For Gaussian ellipsoid data, the edge processing unit first performs a two-dimensional projection transformation on the three-dimensional covariance matrix of each Gaussian ellipsoid based on the camera's intrinsic and extrinsic parameters of the current frame. The three-dimensional covariance matrix describes the shape and orientation of the Gaussian ellipsoid in three-dimensional space. After the projection transformation, the two-dimensional Gaussian distribution parameters corresponding to the Gaussian ellipsoid on the image plane are obtained, including the two-dimensional mean coordinates, the two-dimensional covariance matrix, and the depth value of the ellipsoid relative to the camera.

[0064] After obtaining the two-dimensional Gaussian distribution parameters of all Gaussian ellipsoids, the edges are sorted from near to far according to the depth values ​​of each ellipsoid, and transparency blending calculations are performed on each two-dimensional Gaussian distribution in the sorted order. Specifically, for each pixel on the image plane, all two-dimensional Gaussian distributions that have an overlap relationship with that pixel are traversed, and the transparency contribution value of each Gaussian ellipsoid to that pixel is calculated in turn. The color value is then accumulated by weighting transparency until the accumulated transparency exceeds a preset cutoff threshold or all relevant ellipsoids have been traversed, thus obtaining the final color value of that pixel. After completing the above processing for all pixels, the region rendering result of the static scene is obtained.

[0065] The processing of dynamic point cloud data differs from that of Gaussian ellipsoids. Dynamic point clouds represent dynamic objects that update in real time, such as vehicles and people. The goal of processing them is not to generate a complete rendered image, but to extract depth feature information for terminal fusion. At the edge, the dynamic point cloud is projected onto the image plane to generate a depth map recording the depth values ​​of each pixel. The depth map is then scanned line by line, identifying pixel intervals in each line where the depth values ​​change continuously and the difference is less than a preset second threshold. These intervals are merged into a depth feature segment, recording the starting and ending pixel positions, as well as the average depth value of the pixels within the segment. After line-by-line scanning, depth feature data consisting of several depth feature segments is obtained.

[0066] It should be noted that the merging operation of depth feature segments utilizes the characteristic of continuous change in the surface depth of point cloud objects. For consecutive pixels on the same object surface, their depth values ​​usually change gradually within a small range, satisfying the merging condition that the difference is less than a preset second threshold. However, the depth values ​​between different objects or at object edges often change abruptly, failing to meet the merging condition and naturally forming segment boundaries. Compared to directly transmitting the complete depth map, the representation of depth feature segments only requires recording the start and end positions and average depth of each segment, significantly reducing the amount of data.

[0067] In one embodiment, step S40 specifically includes the following steps: The start position, end position and average depth value of each depth feature segment in the depth feature data transmitted at each edge are analyzed. Based on the start position and end position of each depth feature segment, the corresponding average depth value is filled into the corresponding pixel position of the image plane to obtain the depth distribution map corresponding to each edge. The depth values ​​of each pixel position in the depth distribution map corresponding to each edge are compared, and the edge with the smallest depth value is selected as the source edge of the corresponding pixel position to obtain the mapping relationship from pixel to source edge. Based on the mapping relationship, the color values ​​of each pixel position are extracted from the region rendering results at the corresponding source edge to obtain the 3D model rendering image.

[0068] In this embodiment, after receiving data blocks from multiple edge nodes, the terminal parses the region rendering results and depth feature data in each data block respectively, and completes pixel-level fusion of multi-source rendering results based on the depth feature data.

[0069] The terminal first parses the depth feature data transmitted from each edge, extracting the start position, end position, and average depth value of each depth feature segment. Since the depth feature data is generated in a row-by-row scanning manner at the edges, the parsing process is also performed row by row. For each depth feature segment in each row, all pixel positions within the range from the start to the end position of the segment are filled with the corresponding average depth value, while pixel positions not covered by any depth feature segment are filled with the maximum depth value. After row-by-row processing, a depth distribution map corresponding to each edge is obtained, and the resolution of the depth distribution map is consistent with the region rendering result.

[0070] After acquiring the depth distribution map of each edge, the terminal compares the depth value of each pixel location on the image plane with the depth distribution map of each edge. The smallest depth value means that the corresponding rendered object is closest to the camera in 3D space and should visually occlude other objects with greater depth. Therefore, the terminal selects the edge with the smallest depth value as the source edge of that pixel location and records this correspondence to obtain the mapping relationship from pixel to source edge.

[0071] Based on the above description, the terminal extracts the color value of each pixel position on the image plane from the rendering result of the corresponding source edge region according to the mapping relationship, fills it into the corresponding position of the final output image, and obtains the three-dimensional model rendering image after traversing all pixel positions.

[0072] For example, in a certain frame of rendering, edge A is responsible for rendering the buildings in an intersection area, while edge B is responsible for rendering the dynamic point cloud of vehicles at that intersection. There is pixel overlap between the two in the intersection area of ​​the image plane. For a pixel within the overlapping area, if the depth value of that pixel in the depth distribution map corresponding to edge B is less than the depth value of edge A, it indicates that the vehicle is in front of the building at that pixel location. The terminal sets the source edge of that pixel as edge B and extracts the color from the rendering result of the region at edge B, thus ensuring that the occlusion relationship between the vehicle and the building is correctly represented in the final image.

[0073] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0074] In one embodiment, a cloud-edge-device collaborative 3D model rendering apparatus is provided, which corresponds one-to-one with the cloud-edge-device collaborative 3D model rendering method described in the above embodiments. For example... Figure 5 As shown, this cloud-edge-device collaborative 3D model rendering device includes a temporal search module 501, a partitioning module 502, an edge rendering module 503, and a depth fusion module 504. Detailed descriptions of each functional module are as follows: The temporal search module is used to perform time-aware searches on the detail hierarchy tree of a 3D scene in the cloud. Based on the search results of the previous frame, it performs local subtree traversal on the detail hierarchy tree of the current frame to obtain the detail hierarchy segmentation set corresponding to the current frame. The partitioning module is used to perform geographic partitioning of the detail level segmentation set according to the spatial position and projection size of each Gaussian ellipsoid in the detail level segmentation set, and obtain multiple regional rendering subtasks. The edge rendering module is used to receive Gaussian ellipsoid data and dynamic point cloud data of the corresponding region at the edge according to the multiple region rendering sub-tasks, perform perspective projection transformation and rasterization processing on the received Gaussian ellipsoid, and perform projection and depth feature extraction on the received dynamic point cloud to obtain the region rendering result and the corresponding depth feature data. The depth fusion module is used to perform pixel-level fusion based on depth values ​​on the region rendering results from multiple edge ends according to the depth feature data at the terminal to obtain a three-dimensional model rendering image.

[0075] It should be noted that the information interaction and execution process between the above-mentioned devices / units are based on the same concept as the method embodiments of this application. For details on their specific functions and technical effects, please refer to the method embodiments section, and they will not be repeated here.

[0076] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0077] This application also provides a computer device, such as... Figure 6 As shown, the computer device includes: at least one processor, a memory, and a computer program stored in the memory and executable on the at least one processor. When the processor executes the computer program, it implements the steps in any of the above method embodiments, or when the processor executes the computer program, it implements the functions of each module / unit in the above device embodiments.

[0078] For example, the computer program may be divided into one or more modules / units, which are stored in the memory and executed by the processor to complete this application. The one or more modules / units may be a series of computer program instruction segments capable of performing a specific function, which describe the execution process of the computer program in the computer device.

[0079] Those skilled in the art will understand that Figure 6 The computer device described is merely an example and does not constitute a limitation on the computer device. It may include more or fewer components than shown, or combine certain components, or different components. For example, the computer device may also include input / output devices, network access devices, buses, etc.

[0080] The aforementioned processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), or field-programmable gate arrays (FPGAs). Programmable Gate Array (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor can be a microprocessor or any conventional processor.

[0081] The memory can be an internal storage unit of the computer device, such as a hard drive or RAM. The memory can also be an external storage device of the computer device, such as a plug-in hard drive, Smart Media Card (SMC), Secure Digital (SD) card, or Flash Card. Furthermore, the memory can include both internal and external storage units of the computer device.

[0082] This application also provides a readable storage medium storing a computer program that, when executed by a processor, implements the steps described in the various method embodiments above.

[0083] This application provides a computer program product that, when run on an electronic device, enables the electronic device to perform the steps described in the various method embodiments above.

[0084] If the integrated unit is implemented as 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, all or part of the processes in the methods of the above embodiments of this application can be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include at least: any entity or device capable of carrying computer program code to a photographing device / terminal device, a recording medium, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium. Examples include USB flash drives, portable hard drives, magnetic disks, or optical disks. In some jurisdictions, according to legislation and patent practice, computer-readable media cannot be electrical carrier signals or telecommunication signals.

[0085] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0086] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0087] In the embodiments provided in this application, it should be understood that the disclosed apparatus / devices and methods can be implemented in other ways. For example, the apparatus / device embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

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

[0089] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.

Claims

1. A cloud-edge-device collaborative 3D model rendering method, characterized in that, The cloud-edge-device collaborative 3D model rendering method includes: In the cloud, a time-aware search is performed on the detail hierarchy tree of the 3D scene. Based on the search results of the previous frame, a local subtree traversal is performed on the detail hierarchy tree of the current frame to obtain the detail hierarchy segmentation set corresponding to the current frame. Based on the spatial location and projection size of each Gaussian ellipsoid in the detail level segmentation set, the detail level segmentation set is geographically partitioned to obtain multiple regional rendering subtasks; At the edge, Gaussian ellipsoid data and dynamic point cloud data of the corresponding region are received according to the multiple region rendering sub-tasks. The received Gaussian ellipsoid is subjected to perspective projection transformation and rasterization processing. The received dynamic point cloud is subjected to projection and depth feature extraction to obtain the region rendering result and the corresponding depth feature data. The terminal performs pixel-level fusion based on depth values ​​on the region rendering results from multiple edge ends according to the depth feature data to obtain a three-dimensional model rendering image.

2. The cloud-edge-device collaborative 3D model rendering method according to claim 1, characterized in that, The process of performing a time-aware search on the detail hierarchy tree of a 3D scene in the cloud, and traversing local subtrees of the detail hierarchy tree for the current frame based on the search results of the previous frame to obtain the detail hierarchy segmentation set corresponding to the current frame includes: In the cloud-based detail hierarchy tree of the 3D scene, locate each node corresponding to the detail hierarchy segmentation set of the previous frame, and determine the candidate traversal subtree set according to the parent-child relationship of each node in the detail hierarchy tree. Based on the camera parameters of the current frame, the root nodes of each subtree in the candidate traversal subtree set are projected and transformed. The projection size of each root node on the image plane is calculated. The child nodes of the root nodes whose projection size is greater than the preset level of detail threshold are added to the search queue. The root nodes whose projection size is less than or equal to the preset level of detail threshold are added to the level of detail segmentation set of the current frame, thus obtaining the search queue and a partial level of detail segmentation set. For each node in the search queue, perform projection transformation and projection size calculation in sequence. Update the search queue and the detail level segmentation set according to the comparison result between the projection size and the preset detail level threshold, until the search queue is empty, and obtain the detail level segmentation set corresponding to the current frame.

3. The cloud-edge-device collaborative 3D model rendering method according to claim 1, characterized in that, The step of geographically partitioning the detail level segmentation set based on the spatial location and projected size of each Gaussian ellipsoid in the detail level segmentation set to obtain multiple regional rendering subtasks includes: Spatial clustering is performed on the three-dimensional spatial coordinates of each Gaussian ellipsoid in the detailed level segmentation set, and Gaussian ellipsoids with spatially adjacent locations are divided into the same geographical partition, resulting in multiple initial geographical partitions. The number of Gaussian ellipsoids contained in each initial geographic partition and the projected size of each Gaussian ellipsoid are counted and calculated. The rendering load value of each initial geographic partition is calculated based on the product of the number of Gaussian ellipsoids and the projected size. Based on the rendering load values ​​of each initial geographic partition and the available computing resources of the edge node, multiple initial geographic partitions with a rendering load value difference less than a preset first threshold are assigned to the same edge node to obtain multiple regional rendering subtasks.

4. The cloud-edge-device collaborative 3D model rendering method according to claim 3, characterized in that, The step of allocating multiple initial geographic partitions with a rendering load difference less than a preset first threshold to the same edge node based on the rendering load value of each initial geographic partition and the available computing resources of the edge node, resulting in multiple regional rendering subtasks, includes: The network link bandwidth between the cloud and each edge node, the GPU load of each edge node, and the scene complexity of the current frame's 3D scene are collected to obtain network bandwidth, GPU load, and scene complexity values. The available computing resources of each edge node are weighted and adjusted based on the network bandwidth value, GPU load value, and scene complexity value to obtain the dynamic available resource value of each edge node. Based on the rendering load value of each initial geographic partition and the dynamic available resource value of each edge node, multiple initial geographic partitions whose difference in rendering load value is less than a preset first threshold and whose sum of rendering load value does not exceed the dynamic available resource value of the corresponding edge node are assigned to the same edge node, resulting in multiple regional rendering subtasks.

5. The cloud-edge-device collaborative 3D model rendering method according to claim 1, characterized in that, The process of performing perspective projection transformation and rasterization on the received Gaussian ellipsoid, and projecting and extracting depth features from the received dynamic point cloud to obtain the region rendering result and corresponding depth feature data includes: Based on the camera parameters of the current frame, a two-dimensional projection transformation is performed on the three-dimensional covariance matrix of each Gaussian ellipsoid to obtain the two-dimensional Gaussian distribution parameters and corresponding depth values ​​of each Gaussian ellipsoid on the image plane. The two-dimensional Gaussian distribution parameters are sorted from near to far according to their depth values. The transparency of each two-dimensional Gaussian distribution parameter is then calculated sequentially according to the sorted order to obtain the region rendering result of the static scene. The received dynamic point cloud data is projected to generate a depth map. The depth map is scanned according to the image rows. Continuous pixel segments with a depth value difference less than a preset second threshold are merged into depth feature segments. The start position, end position and average depth value of each depth feature segment are recorded to obtain depth feature data. The region rendering result of the static scene and the depth feature data are transmitted to the terminal as region rendering result and corresponding depth feature data.

6. The cloud-edge-device collaborative 3D model rendering method according to claim 1, characterized in that, The step of performing pixel-level fusion based on depth values ​​on the region rendering results from multiple edge ends according to the depth feature data at the terminal to obtain a 3D model rendering image includes: The start position, end position and average depth value of each depth feature segment in the depth feature data transmitted at each edge are analyzed. Based on the start position and end position of each depth feature segment, the corresponding average depth value is filled into the corresponding pixel position of the image plane to obtain the depth distribution map corresponding to each edge. The depth values ​​of each pixel position in the depth distribution map corresponding to each edge are compared, and the edge with the smallest depth value is selected as the source edge of the corresponding pixel position to obtain the mapping relationship from pixel to source edge. Based on the mapping relationship, the color values ​​of each pixel position are extracted from the region rendering results at the corresponding source edge to obtain the 3D model rendering image.

7. A cloud-edge-device collaborative 3D model rendering device, characterized in that, include: The temporal search module is used to perform time-aware searches on the detail hierarchy tree of a 3D scene in the cloud. Based on the search results of the previous frame, it performs local subtree traversal on the detail hierarchy tree of the current frame to obtain the detail hierarchy segmentation set corresponding to the current frame. The partitioning module is used to perform geographic partitioning of the detail level segmentation set according to the spatial position and projection size of each Gaussian ellipsoid in the detail level segmentation set, and obtain multiple regional rendering subtasks. The edge rendering module is used to receive Gaussian ellipsoid data and dynamic point cloud data of the corresponding region at the edge according to the multiple region rendering sub-tasks, perform perspective projection transformation and rasterization processing on the received Gaussian ellipsoid, and perform projection and depth feature extraction on the received dynamic point cloud to obtain the region rendering result and the corresponding depth feature data. The depth fusion module is used to perform pixel-level fusion based on depth values ​​on the region rendering results from multiple edge ends according to the depth feature data at the terminal to obtain a three-dimensional model rendering image.

8. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the cloud-edge-device collaborative 3D model rendering method as described in any one of claims 1 to 6.

9. A readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the cloud-edge-device collaborative 3D model rendering method as described in any one of claims 1 to 6.

10. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, enables the implementation of the steps of the cloud-edge-device collaborative 3D model rendering method as described in any one of claims 1 to 6.

Images