Large-scale Scene Organization and Dynamic Scheduling Method Based on Two-dimensional Gaussian Sputtering

Abstract

The large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering provided by the present invention relates to the technical field of scene rendering, and includes: dividing a large-scale scene into several sub-scenes, where there is an overlapping area between two adjacent sub-scenes; recursively creating bounding boxes using the median partitioning algorithm to perform spatial segmentation on the sub-scenes and generate a BVH tree; dynamically selecting nodes in the LOD tree to generate an LOD structure according to the granularity of the camera distance to the corresponding node to achieve the scene performance of the close view or the medium view; based on the LOD tree, using the breadth-first traversal of the binary tree method, generating a hierarchical level of detail HLOD using a preset proportion of the leaf nodes of the LOD tree to achieve the scene performance of the distant view; merging several sub-scenes; and being able to improve the rendering efficiency while maintaining the visual quality.

Description

Technical Field

[0001] The present invention relates to the technical field of scene rendering, and in particular to a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering. Background Art

[0002] 2DGS is an algorithm that deeply improves 3DGS. Its core idea is to simplify the 3D volume into a series of 2D oriented flat Gaussian disks. Unlike 3DGS, 2DGS can provide visual Figure 1 Consistent geometry representation. In order to accurately restore the surface and achieve stable optimization, 2DGS introduces a perspective-accurate 2Dsplatting process based on ray splatting intersection and rasterization. In addition, 2DGS also adds depth distortion and normal consistency terms, which has good support for functions such as relighting and material editing. The differentiable renderer of 2DGS can achieve noise-free and detailed geometry reconstruction while maintaining excellent appearance quality, fast training speed and real-time rendering capabilities. Its limitations: It judges the surface of the scene by opacity, and the representation effect for semi-transparent objects will be worse; its densification strategy mainly focuses on areas with richer textures, and the representation of weaker texture areas is poor. The rendering efficiency is low when performing real-time rendering in large-scale scenes. The goal is to create a data structure to represent the primitives generated by the original 2DGS optimization to dynamically call LOD in the near and mid-ground and HLOD in the distant view. Summary of the invention

[0003] In response to the above problems, the present invention provides a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering, which solves the technical problem of low frame rate when performing real-time rendering in large-scale scenes in the prior art, and can improve rendering efficiency while maintaining visual quality.

[0004] The embodiment of the present invention provides a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering, including:

[0005] Divide the large-scale scene into blocks to obtain a number of block scenes, wherein there is an overlapping area between two adjacent block scenes;

[0006] The median partitioning algorithm is used to recursively create bounding boxes, spatially segment the block scene, and generate a BVH tree;

[0007] Based on the BVH tree, generate an LOD tree;

[0008] Dynamically select nodes in the LOD tree to generate LOD structure according to the granularity of the node corresponding to the camera distance, so as to achieve the scene performance of close-up or mid-range;

[0009] Based on the LOD tree, in a breadth-first traversal of the binary tree manner, use a preset proportion of the leaf nodes of the LOD tree to generate a hierarchical level of detail HLOD to achieve the scene performance of the distant view;

[0010] Merge several segmented scenes.

[0011] In some embodiments, the large-scale scene is segmented to obtain several segmented scenes, wherein there is an overlapping area between two adjacent segmented scenes, including:

[0012] Average the point cloud of the large-scale scene according to the physical position for segmentation;

[0013] Create a bounding box, and use the bounding box to capture the segmented parts to obtain several segmented scenes.

[0014] In some embodiments, the median partitioning algorithm is used to recursively create a bounding box to perform spatial segmentation on the segmented scene and generate a BVH tree, including:

[0015] Calculate the two-dimensional mean position of each Gaussian disk in the segmented scene, and project all the two-dimensional mean positions along the longest axis of the current bounding box to obtain an object set;

[0016] Divide the object set according to the median of the projections of the two-dimensional mean positions of all 2D Gaussian disks to obtain two subsets;

[0017] Recursively execute the above steps for each subset, create a new bounding box for each subset, and continue to divide until the number of 2D Gaussian disks contained in each subset is less than a preset threshold;

[0018] Use the bounding boxes created during the recursive process as nodes to construct the tree structure of the BVH tree.

[0019] In some embodiments, the use of the bounding boxes created during the recursive process as nodes to construct the tree structure of the BVH includes:

[0020] When the number of 2D Gaussian disks in the subset is less than the preset threshold, stop the recursion and use the subset as a leaf node;

[0021] For each non-leaf node, create an intermediate node and calculate the 2D Gaussian disks of the intermediate node, wherein the intermediate node contains references to its child nodes;

[0022] Based on the intermediate node and the leaf nodes, construct the tree structure of the BVH tree.

[0023] In some embodiments, the for each non-leaf node, create an intermediate node and calculate the 2D Gaussian disks of the intermediate node, including:

[0024] Position merging:

[0025]

[0026] where μ is the position of the 2D Gaussian disk of the intermediate node, μ i is the position of the 2D Gaussian disk of the i-th child node, and τ is the weight of the i-th child node, which is determined by the importance of the child node;

[0027] Tangent vector merging:

[0028]

[0029] where t u , t v are the tangent vectors of the intermediate node, is the tangent vector of the i-th child node, is the weight of the i-th child node;

[0030] Scaling vector merging:

[0031]

[0032] where s u , s v are the scaling vectors of the intermediate node, which determine the size of the Gaussian disk, is the scaling vector of the i-th child node, and ω is the weight of the i-th child node.

[0033] In some embodiments, generating an LOD tree based on the BVH tree includes:

[0034] Creating an LOD tree node for each node based on the BVH tree;

[0035] Using the 2D Gaussian disk of the leaf node of the BVH tree as the 2D Gaussian disk of the child node of the LOD tree;

[0036] From bottom to top, merging the 2D Gaussian disks of the child nodes of the LOD tree to create a new 2D Gaussian disk for each intermediate node of the LOD tree, where the attributes of the 2D Gaussian disk of the intermediate node are obtained by weighted averaging the attributes of the next-level nodes.

[0037] In some embodiments, obtaining the attributes of the 2D Gaussian disk of the intermediate node by weighted averaging the attributes of the next-level nodes includes:

[0038] Performing weighted averaging on the positions of the 2D Gaussian disks of each child node to obtain the position μ mid of the intermediate node:

[0039]

[0040] wherein, μ j is the 2D Gaussian disk position of the j-th child node, and α is the corresponding weight determined by the mass of the child node.

[0041] The tangent vectors (t umid , t vmid ) of the intermediate node are calculated using the weighted average method:

[0042]

[0043] wherein, is the tangent of the j-th child node, and β is the corresponding weight;

[0044] The scaling vectors of each child node are weighted-averaged to obtain the scaling vector of the intermediate node

[0045]

[0046] wherein, is the scaling vector of the j-th child node, and γ is the corresponding weight;

[0047] The opacities of each child node are weighted-averaged to obtain the opacity O mid of the intermediate node:

[0048]

[0049] wherein, O j is the opacity of the j-th child node, and δ is the corresponding weight;

[0050] The color information of each child node is weighted-averaged to obtain the color information C mid of the intermediate node:

[0051]

[0052] wherein, C j is the color information of the j-th child node, and ε is the corresponding weight related to the opacity or the volume of the Gaussian disk.

[0053] In some embodiments, it includes:

[0054] Optimizing the objective function of the intermediate node:

[0055]

[0056] wherein, dd(μ j , μ) is the distance between the position of the child node and the position of the merged node, and λ1, λ2, λ3, λ4 are weights.

[0057] In some embodiments, it includes:

[0058] Interpolate the opacity, position, tangent vector, and scaling vector.

[0059] In some embodiments, the merging of several block scenes includes:

[0060] Merge the 2D Gaussian disk of the current block scene with the 2D Gaussian disk inherited from the adjacent block scene, where during the merging process, the 2D Gaussian disk of the current block scene aligns with the 2D Gaussian disk of the adjacent block scene through spatial position matching.

[0061] Compared with the prior art, the present invention has the following beneficial effects:

[0062] By dividing a large-scale scene into several block scenes, where there is an overlapping area between two adjacent block scenes; using the median partitioning algorithm to recursively create bounding boxes to perform spatial segmentation on the block scenes and generate a BVH tree; dynamically selecting nodes in the LOD tree to generate an LOD structure according to the granularity of the camera distance to the corresponding node to achieve the scene performance of close-up or medium-shot; based on the LOD tree, using the breadth-first traversal of the binary tree method and using a preset proportion of the leaf nodes of the LOD tree to generate a hierarchical level of detail HLOD to achieve the scene performance of the long-shot; merging several block scenes; it can improve the rendering efficiency while maintaining the visual quality. BRIEF DESCRIPTION OF THE DRAWINGS

[0063] The following further describes the embodiments of the present invention with reference to the drawings:

[0064] Figure 1 It is a schematic flowchart of the implementation of the large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering provided by the embodiment of the present invention;

[0065] Figure 2 It is a schematic structural diagram of the electronic device provided by the embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0066] In order to make the objectives, technical solutions, and advantages of the present invention clearer, the present invention will be further described in detail below with reference to the drawings. The described embodiments should not be construed as limiting the present invention. All other embodiments obtained by those of ordinary skill in the art without creative efforts fall within the scope of protection of the present invention.

[0067] In the following description, reference is made to "some embodiments", which describe a subset of all possible embodiments. However, it can be understood that "some embodiments" can be the same subset or different subsets of all possible embodiments and can be combined with each other without conflict.

[0068] If similar descriptions such as "first / second / third" appear in the application documents, the following explanation shall be added. In the following description, the terms "first / second / third" only distinguish similar objects and do not represent a specific order for the objects. Understandably, "first / second / third" can be interchanged with a specific order or sequence when permitted, so that the embodiments of the present invention described herein can be implemented in an order other than that illustrated or described herein.

[0069] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by those of ordinary skill in the technical field to which the present invention belongs. The terms used herein are only for the purpose of describing the embodiments of the present invention and are not intended to limit the present invention.

[0070] Based on the problems existing in the related art, the embodiments of the present invention provide a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering. The execution subject of the dynamic scheduling method can be an electronic device. The electronic device can be various types of terminals such as a laptop computer, a tablet computer, a desktop computer, a set-top box, a mobile device (e.g., a mobile phone, a portable music player, a personal digital assistant, a dedicated messaging device, a portable gaming device), or can also be implemented as a server. The server can be an independent physical server, or a server cluster or a distributed system composed of multiple physical servers, or can also be a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, Content Delivery Network (CDN), and big data and artificial intelligence platforms.

[0071] In some embodiments, the functions implemented by the dynamic scheduling method provided by the embodiments of the present invention can be realized by a processor of an electronic device calling program code, where the program code can be stored in a computer storage medium.

[0072] The embodiments of the present invention provide a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering, Figure 1 which is a schematic flow chart of the implementation of the large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering provided by the embodiments of the present invention, as Figure 1 shown, including:

[0073] Step S1: Divide a large-scale scene into several sub-scenes, where there is an overlapping area between two adjacent sub-scenes;

[0074] In some embodiments, step S1 includes:

[0075] Step S11: Divide the point cloud of the large-scale scene into equal parts according to the physical position;

[0076] Step S12: Create a bounding box, and use the bounding box to capture the divided parts to obtain a number of divided-scene parts.

[0077] In the embodiment of the present invention, the point cloud of the large-scale scene is divided into equal parts according to the physical position. Exemplarily, the point cloud of the large-scale scene can be divided into eight equal parts. Then create a bounding box, and use the bounding box to capture the corresponding divided parts in the large-scale scene to obtain a number of divided-scene parts. When dividing, a certain degree of visual smooth transition between the divided-scene parts is achieved by overlapping the regions between the divided-scene parts.

[0078] Step S2: Recursively create a bounding box using the median partitioning algorithm to perform spatial segmentation on the divided-scene parts and generate a BVH tree;

[0079] In some embodiments, step S2 includes:

[0080] Step S21: Calculate the two-dimensional mean position of each Gaussian disk in the divided-scene part, and project all the two-dimensional mean positions along the longest axis of the current bounding box to obtain an object set;

[0081] Step S22: Divide the object set according to the median of the projections of the two-dimensional mean positions of all 2D Gaussian disks to obtain two subsets;

[0082] Step S23: Recursively execute the above steps for each subset, create a new bounding box for each subset, and continue to divide until the number of 2D Gaussian disks contained in each subset is less than a preset threshold;

[0083] Step S24: Use the bounding boxes created during the recursive process as nodes to construct the tree structure of the BVH tree.

[0084] In the embodiments of the present invention, by calculating the two-dimensional mean positions of each 2D Gaussian disk, the center points of these objects can be obtained. Then, project these center points along the longest axis of the current bounding box, so that a one-dimensional set of projection points can be obtained, and these points represent the positions of the original two-dimensional object set in the low-dimensional space. Use the median of the projection points as the division basis to divide the object set into two subsets. Recursively execute the previous steps until the number of objects in each subset is less than a preset threshold. The preset threshold is an important parameter, which determines the number of objects contained in the leaf nodes of the BVH. When the number of objects in the subset is less than this threshold, it is considered that this subset is small enough and does not need further division. This can avoid the excessive complexity of the BVH tree caused by over-division and affect the query efficiency. Use the bounding boxes created during the recursive process as nodes to construct a tree structure, that is, the BVH tree. In this tree structure, each node represents a bounding box, the leaf nodes contain the original 2D Gaussian disks, and the non-leaf nodes represent larger bounding boxes obtained by merging the bounding boxes of the child nodes. In this way, the BVH tree forms a hierarchical space division, which can be used to quickly determine the spatial relationships between objects and optimize operations such as collision detection and ray tracing.

[0085] In some embodiments, step S24 includes:

[0086] Step S241: When the number of 2D Gaussian disks in the subset is less than the preset threshold, stop the recursion and use the subset as a leaf node;

[0087] Step S242: For each non-leaf node, create an intermediate node and calculate the 2D Gaussian disk of the intermediate node, where the intermediate node contains references to its child nodes;

[0088] Step S243: Based on the intermediate node and the leaf node, construct the tree structure of the BVH tree.

[0089] In the embodiments of the present invention, intermediate nodes are non-leaf nodes in the BVH tree. They do not directly contain the original objects, but contain references to their child nodes. Each intermediate node represents a larger bounding box, which is obtained by merging the bounding boxes of its child nodes. When creating an intermediate node, it is necessary to calculate the 2D Gaussian disk of this intermediate node, which is usually achieved by merging the 2D Gaussian disks of its child nodes. This process ensures that the bounding box of the intermediate node can tightly enclose all the objects in its child nodes.

[0090] In some embodiments, step S242 includes:

[0091] Step S2421: Position merging:

[0092]

[0093] where μ is the position of the 2D Gaussian disk of the intermediate node, and μ i is the position of the 2D Gaussian disk of the i-th child node, and τ is the weight of the i-th child node, which is determined by the importance of the child node;

[0094] Step S2422: Tangent vector merging:

[0095]

[0096] where t u and t v are the tangent vectors of the intermediate node, is the tangent vector of the i-th child node, and is the weight of the i-th child node;

[0097] Step S2423: Scaling vector merging:

[0098]

[0099] where s u and s v are the scaling vectors of the intermediate node, which determine the size of the Gaussian disk, is the scaling vector of the i-th child node, and ω is the weight of the i-th child node.

[0100] In the embodiments of the present invention, the positions, tangent vectors, and scaling vectors of the child nodes are merged through a weighted average algorithm, and a 2D Gaussian disk of the intermediate node can be created through the merged positions, tangent vectors, and scaling vectors.

[0101] Step S3: Generate an LOD tree based on the BVH tree;

[0102] In some embodiments, step S3 includes:

[0103] Step S31: Create an LOD tree node for each node based on the BVH tree;

[0104] Step S32: Use the 2D Gaussian disk of the leaf node of the BVH tree as the 2D Gaussian disk of the child node of the LOD tree;

[0105] Step S33: From bottom to top, merge the 2D Gaussian disks of the child nodes of the LOD tree, and create a new 2D Gaussian disk for each intermediate node of the LOD tree, where the attributes of the 2D Gaussian disk of the intermediate node are obtained by weighted averaging the attributes of the next-level nodes.

[0106] In the embodiments of the present invention, a corresponding LOD tree node is created for each node based on the BVH tree, and each node in the LOD tree represents the representation of the area at different levels of detail. The leaf nodes of the LOD tree directly correspond to the leaf nodes of the BVH tree. The leaf nodes of the BVH tree contain the original objects (2D Gaussian disks), and these objects are the most detailed representations in the LOD tree. This means that at the bottom layer of the LOD tree, each node contains the original objects without further simplification or merging. Starting from the leaf nodes of the LOD tree, the nodes are gradually merged upward until the intermediate nodes of the entire LOD tree are constructed. The 2D Gaussian disk of each intermediate node is not simply one of the 2D Gaussian disks of the child nodes, but by means of weighted average, the attributes of the 2D Gaussian disks of the child nodes are combined to form a new 2D Gaussian disk, which can ensure the visual continuity and consistency of the LOD tree while allowing the use of models with different complexities at different distances.

[0107] In some embodiments, step S33 includes:

[0108] Step S331: Perform weighted average on the positions of the 2D Gaussian disks of each child node to obtain the position μ of the intermediate node mid :

[0109]

[0110] where μ j is the position of the 2D Gaussian disk of the j-th child node, and α is the corresponding weight determined by the quality of the child node.

[0111] Step S332: Calculate the tangent vectors (t umid , t vmid ) of the intermediate node using the weighted average method:

[0112]

[0113] where is the tangent of the j-th child node, and β is the corresponding weight;

[0114] Step S333: Perform weighted average on the scaling vectors of each child node to obtain the scaling vector of the intermediate node

[0115]

[0116] where is the scaling vector of the j-th child node, and γ is the corresponding weight;

[0117] Step S334: Perform weighted average on the opacity of each child node to obtain the opacity O of the intermediate nodemid :

[0118]

[0119] wherein, O j is the opacity of the j-th child node, and δ is the corresponding weight;

[0120] Step S335: Perform weighted averaging on the color information of each child node to obtain the color information C of the intermediate node mid :

[0121]

[0122] wherein, C j is the color information of the j-th child node, and ε is the corresponding weight, which is related to the opacity or the volume of the Gaussian disk.

[0123] In the embodiments of the present invention, by means of weighted averaging, the positions, tangent vectors, scaling vectors, opacities, and color information of the 2D Gaussian disks of the child nodes are combined to form a new 2D Gaussian disk. The weights for weighted averaging are usually determined based on the visual importance of the child nodes or the distance from the observer. For the opacity, it is necessary to ensure that the opacities of multiple 2D Gaussian disks do not exceed 1.

[0124] In some embodiments, it includes:

[0125] Step S336: Optimize the objective function of the intermediate node:

[0126]

[0127] wherein, d(μ j , μ) is the distance between the position of the child node and the position of the merged node, and λ1, λ2, λ3, λ4 are weights.

[0128] In the embodiments of the present invention, by defining an objective function, the error or difference of the 2D Gaussian disk of the intermediate node is minimized.

[0129] In some embodiments, it includes:

[0130] Step S337: Interpolate the opacity, position, tangent vector, and scaling vector.

[0131] In the embodiments of the present invention, interpolation can be performed on the opacity, position, tangent vector, and scaling vector:

[0132] O mid (t) = tO child + (1 - t)O parent

[0133] μmid μ(t) = tμ child + (1 - t)μ parent

[0134]

[0135] Wherein, t is time. Through the above interpolation process, smooth transitions between different levels can be ensured.

[0136] Step S4: Dynamically select nodes in the LOD tree to generate the LOD structure according to the granularity of the camera distance from the corresponding node, so as to achieve the scene performance of the close view or the medium view;

[0137] In the embodiment of the present invention, according to the distance between the camera and the node, a target granularity threshold τ is set ∈ , and the granularity of the node ∈(n) = max(AABB(n)) can be defined, where AABB(n) is the bounding box of node n. If the granularity ∈(n) of a certain node is less than the target granularity threshold τ ∈ , then this node is selected as the current rendering object. If the parent node does not meet the target granularity, the child node will be selected for rendering.

[0138] In the embodiment of the present invention, for the nodes with a relatively close camera distance, a higher-detail LOD structure is selected for rendering to ensure that the objects in the close view and the medium view have sufficient details and clarity, and can provide richer visual information when the user observes these objects.

[0139] Step S5: Based on the LOD tree, adopt the breadth-first traversal of the binary tree method, and use a preset proportion of the leaf nodes of the LOD tree to generate the hierarchical level of detail HLOD to achieve the scene performance of the distant view.

[0140] In the embodiment of the present invention, adopting the breadth-first traversal of the binary tree method, visit the nodes of the tree layer by layer in the order from top to bottom, and select a certain proportion of leaf nodes to generate the hierarchical level of detail HLOD, representing different levels of detail. This proportion can be adjusted according to actual needs to balance the visual effect and performance.

[0141] In the embodiment of the present invention, for the nodes with a relatively far camera distance, the hierarchical level of detail HLOD is used for rendering, and a lower-detail model is used at a farther distance, thereby reducing the complexity and calculation amount of rendering and improving the rendering efficiency.

[0142] Step S6: Merge several segmented scenes.

[0143] In some embodiments, step S6 includes:

[0144] Step S61: Merge the 2D Gaussian disk of the current segmented scene with the 2D Gaussian disk inherited from the adjacent segmented scene. During the merging process, the 2D Gaussian disk of the current segmented scene aligns the 2D Gaussian disk of the adjacent segmented scene through spatial position matching.

[0145] In the embodiments of the present invention, after independent training, there may be different degrees of differences in the image effects among the segmented scenes. Especially in the overlapping regions between adjacent segmented scenes, it will affect the consistency of the entire scene. Therefore, it is necessary to merge several segmented scenes to ensure the continuity and consistency of the visual effects. In each segmented scene, merge the 2D Gaussian disk of the current segmented scene with the 2D Gaussian disk inherited from the adjacent segmented scene. Ensure that the boundary region of the current segmented scene can seamlessly connect with the 2D Gaussian disk of the adjacent segmented scene to form visual continuity. During the merging process, the 2D Gaussian disk of the current segmented scene aligns the 2D Gaussian disk of the adjacent segmented scene through spatial position matching to avoid inconsistent visual effects in the overlapping regions. It can be understood that regardless of whether it is a close-up, medium shot, or long shot, when the visible area disappears, it is necessary to dynamically unload the data of the corresponding partition to release memory and reduce resource occupancy.

[0146] In summary, by creating bounding boxes, segmenting a large-scale scene to obtain several segmented scenes, where there are overlapping regions between two adjacent segmented scenes; using the median partitioning algorithm to recursively create bounding boxes to perform spatial segmentation on the segmented scenes to generate a BVH tree; dynamically selecting nodes in the LOD tree to generate an LOD structure according to the granularity of the camera distance to the corresponding node to achieve the scene performance of a close-up or medium shot; based on the LOD tree, using the breadth-first traversal of the binary tree method, generating a hierarchical level of detail HLOD using a preset proportion of the leaf nodes of the LOD tree to achieve the scene performance of a long shot; merging several segmented scenes; it is possible to improve the rendering efficiency while maintaining the visual quality.

[0147] It should be noted that in the embodiments of the present invention, if the above-mentioned dynamic scheduling method is implemented in the form of software function modules and sold or used as an independent product, it can also be stored in a computer-readable storage medium. Based on such an understanding, the technical solution of the embodiments of the present invention, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes: various media such as USB flash drives, mobile hard disks, read-only memories (ROM, Read-Only Memory), magnetic disks, or optical discs that can store program codes. In this way, the embodiments of the present invention are not limited to any specific combination of hardware and software.

[0148] Correspondingly, an embodiment of the present invention provides a storage medium, on which a computer program is stored, and is characterized in that when the computer program is executed by a processor, the steps in the dynamic scheduling method provided in the above embodiments are implemented.

[0149] An embodiment of the present invention provides an electronic device; Figure 2 is a schematic structural diagram of the electronic device provided in the embodiment of the present invention, as Figure 2 shown, the electronic device 400 includes: a processor 401, at least one communication bus 402, a user interface 403, at least one external communication interface 404, and a memory 405. Among them, the communication bus 402 is configured to implement connection communication between these components. Among them, the user interface 403 may include a display screen, and the external communication interface 404 may include a standard wired interface and a wireless interface. The processor 401 is configured to execute the program of the dynamic scheduling method stored in the memory to implement the steps in the dynamic scheduling method provided in the above embodiments.

[0150] It should be pointed out here that: the descriptions of the above storage medium and electronic device embodiments are similar to the descriptions of the above method embodiments and have similar beneficial effects to the method embodiments. For the technical details not disclosed in the embodiments of the storage medium and device of the present invention, please refer to the descriptions of the method embodiments of the present invention for understanding.

[0151] It should be understood that the "one embodiment" or "an embodiment" mentioned throughout the specification means that the specific features, structures or characteristics related to the embodiment are included in at least one embodiment of the present invention. Therefore, the "in one embodiment" or "in an embodiment" that appears throughout the specification does not necessarily refer to the same embodiment. In addition, these specific features, structures or characteristics may be combined in one or more embodiments in any suitable manner. It should be understood that in various embodiments of the present invention, the magnitudes of the sequence numbers of the above processes do not mean the order of execution. The order of execution of each process should be determined by its function and internal logic, and should not constitute any limitation to the implementation process of the embodiments of the present invention. The sequence numbers of the embodiments of the present invention above are only for description and do not represent the advantages or disadvantages of the embodiments.

[0152] It should be noted that in this text, the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, object or device comprising a series of elements not only includes those elements, but also includes other elements not expressly listed, or also includes elements inherent to such process, method, object or device. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of additional identical elements in the process, method, object or device comprising that element.

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

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

[0155] In addition, each functional unit in the embodiments of the present invention can be all integrated in a processing unit, or each unit can be separately a unit, or two or more units can be integrated in one unit; the above integrated units can be implemented in the form of hardware, or in the form of a combination of hardware and software functional units.

[0156] Those of ordinary skill in the art can understand that all or part of the steps of implementing the above method embodiments can be completed by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When the program is executed, it performs the steps including those of the above method embodiments. The aforementioned storage medium includes various media that can store program codes, such as removable storage devices, read-only memories (ROMs), magnetic disks, or optical discs.

[0157] Alternatively, if the above-integrated unit is implemented in the form of a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium. Based on such an understanding, the technical solution of the embodiments of the present invention, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for causing a controller to execute all or part of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media that can store program codes, such as removable storage devices, ROMs, magnetic disks, or optical discs.

[0158] As described above, the above are only the implementation manners of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art within the technical scope disclosed by the present invention can easily think of changes or substitutions, which should all be covered by the protection scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims

1. A large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering, characterized in that: include: Divide the large-scale scene into blocks to obtain a number of block scenes, wherein there is an overlapping area between two adjacent block scenes; The median partitioning algorithm is used to recursively create bounding boxes, spatially segment the block scene, and generate a BVH tree; The median partitioning algorithm is used to recursively create a bounding box, spatially divide the block scene, and generate a BVH tree, including: Calculate the 2D mean position of each Gaussian disk in the block scene, and project all 2D mean positions along the longest axis of the current bounding box to obtain an object set; The object set is divided according to the median of the projection of the two-dimensional mean position of all 2D Gaussian disks to obtain two subsets; Recursively perform the above steps for each subset, create a new bounding box for each subset, and continue dividing until the number of 2D Gaussian disks contained in each subset is less than the preset threshold; Use the bounding boxes created in the recursive process as nodes to build the tree structure of the BVH tree; The bounding box created in the recursive process is used as a node to construct a tree structure of BVH, including: When the number of 2D Gaussian disks in a subset is less than a preset threshold, the recursion is stopped and the subset is taken as a leaf node; For each non-leaf node, create an intermediate node and calculate the 2D Gaussian disk of the intermediate node, where the intermediate node contains references to its child nodes; Based on the intermediate nodes and leaf nodes, construct a tree structure of a BVH tree; For each non-leaf node, an intermediate node is created and the 2D Gaussian disk of the intermediate node is calculated, including: Position Merge: Where μ is the position of the 2D Gaussian disk at the middle node, μ i is the 2D Gaussian disk position of the ith child node, τ is the weight of the ith child node, which is determined by the importance of the child node; Tangent vector merging: Where, t u ,t v is the tangent vector at the midpoint, is the tangent vector of the ith child node, is the weight of the i-th child node; Scaling vector merge: In the formula, s u 、s v is the scaling vector of the middle node, which determines the size of the Gaussian disk. is the scaling vector of the ith child node, ω is the weight of the ith child node; Based on the BVH tree, generate an LOD tree; Dynamically select nodes in the LOD tree to generate LOD structure according to the granularity of the node corresponding to the camera distance, so as to achieve the scene performance of close-up or mid-range; Based on the LOD tree, a breadth-traversal binary tree method is adopted, and leaf nodes of a preset proportion of the LOD tree are used to generate a hierarchical level of detail HLOD to achieve a distant scene performance; Merge several block scenes.

2. The method according to claim 1, characterized in that The large-scale scene is divided into blocks to obtain a plurality of block scenes, wherein there is an overlapping area between two adjacent block scenes, including: The point cloud of large-scale scenes is evenly divided into blocks according to physical locations; A bounding box is created, and the blocks are captured using the bounding box to obtain a plurality of block scenes.

3. The method according to claim 1, characterized in that The step of generating a LOD tree based on the BVH tree comprises: Based on the BVH tree, create an LOD tree node for each node; Use the 2D Gaussian disk of the leaf node of the BVH tree as the 2D Gaussian disk of the child node of the LOD tree; From bottom to top, the 2D Gaussian disks of the child nodes of the LOD tree are merged to create a new 2D Gaussian disk for each intermediate node of the LOD tree, wherein the attributes of the 2D Gaussian disk of the intermediate node are obtained by weighted averaging the attributes of the next level nodes.

4. The method according to claim 3, characterized in that The attributes of the 2D Gaussian disk of the intermediate node are obtained by weighted averaging the attributes of the next level nodes, including: Perform weighted averaging on the 2D Gaussian disk position of each child node to obtain the position μ of the middle node mid : In the formula, μ j is the 2D Gaussian disk position of the jth child node, α is the corresponding weight, which is determined by the quality of the child node; Use the weighted average method to calculate the tangent vector (t umid ,t vmid ): In the formula, is the tangent of the jth child node, and β is the corresponding weight; Take a weighted average of the scaling vectors of each child node to get the scaling vector of the middle node In the formula, is the scaling vector of the jth child node, and γ is the corresponding weight; Take a weighted average of the opacity of each child node to get the opacity of the middle node O mid : In the formula, O j is the opacity of the jth child node, and δ is the corresponding weight; Perform weighted average on the color information of each child node to obtain the color information C of the intermediate node mid : In the formula, C j is the color information of the jth child node, and ε is the corresponding weight, which is related to the opacity or volume of the Gaussian disk.

5. The method according to claim 4, characterized in that include: Optimize the objective function of the intermediate nodes: Among them, d(μ j ,μ) is the distance between the child node position and the merged node position, λ1,λ2,λ3,λ4 are weights.

6. The method according to claim 4, characterized in that include: Interpolate opacity, position, tangent, and scale vectors.

7. The method according to claim 1, characterized in that The merging of the plurality of block scenes includes: The 2D Gaussian disk of the current block scene is merged with the 2D Gaussian disk inherited from the adjacent block scene, wherein during the merging process, the 2D Gaussian disk of the current block scene is aligned with the 2D Gaussian disk of the adjacent block scene through spatial position matching.

Images