Large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering

Abstract

The invention provides a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering, and relates to the technical field of scene rendering, and the method comprises the steps: carrying out the blocking of a large-scale scene, obtaining a plurality of block scenes, and enabling the two adjacent block scenes to have an overlapping region; recursively creating a bounding box by adopting a median partitioning algorithm, and performing space partitioning on the partitioned scene to generate a BVH tree; nodes in the LOD tree are dynamically selected to generate an LOD structure according to the granularity of the nodes corresponding to the camera distance, and the scene performance of close-shot or medium-shot is achieved; based on the LOD tree, adopting a breadth traversal binary tree mode, and using leaf nodes of a preset proportion of the LOD tree to generate a hierarchical level of detail (HLOD) to realize long-range scene performance; combining the plurality of block scenes; the rendering efficiency can be improved while the visual quality is maintained.

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, 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;

[0010] Merge several block scenes.

[0011] In some embodiments, 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:

[0012] The point cloud of large-scale scenes is evenly divided into blocks according to physical locations;

[0013] A bounding box is created, and the blocks are captured using the bounding box to obtain a plurality of block scenes.

[0014] In some embodiments, the recursive creation of bounding boxes by using a median partitioning algorithm to spatially segment the block scene and generate a BVH tree includes:

[0015] 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;

[0016] 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;

[0017] 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;

[0018] The tree structure of the BVH tree is constructed using the bounding boxes created in the recursive process as nodes.

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

[0020] 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;

[0021] 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;

[0022] Based on the intermediate nodes and leaf nodes, a tree structure of a BVH tree is constructed.

[0023] In some embodiments, for each non-leaf node, creating an intermediate node and calculating a 2D Gaussian disk of the intermediate node comprises:

[0024] Position Merge:

[0025]

[0026] 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 usually determined by the importance of the child node;

[0027] Tangent vector merging:

[0028]

[0029] In the formula, 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;

[0030] Scaling vector merge:

[0031]

[0032] 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, and ω is the weight of the ith child node.

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

[0034] Based on the BVH tree, create an LOD tree node for each node;

[0035] 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;

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

[0037] In some embodiments, the attributes of the 2D Gaussian disk of the intermediate node are obtained by weighted averaging the attributes of the next level nodes, including:

[0038] Perform weighted averaging on the 2D Gaussian disk position of each child node to obtain the position μ of the middle node mid :

[0039]

[0040] In the formula, μ j is the 2D Gaussian disk position of the jth child node, and α is the corresponding weight, which is usually determined by the quality of the child node.

[0041] Use weighted average method to calculate the tangent vector of the middle node

[0042]

[0043] In the formula, is the tangent of the jth child node, and β is the corresponding weight;

[0044] Take a weighted average of the scaling vectors of each child node to get the scaling vector of the middle node

[0045]

[0046] In the formula, is the scaling vector of the jth child node, and γ is the corresponding weight;

[0047] Take a weighted average of the opacity of each child node to get the opacity of the middle node O mid :

[0048]

[0049] In the formula, O j is the opacity of the jth child node, and δ is the corresponding weight;

[0050] Perform weighted average on the color information of each child node to obtain the color information C of the intermediate node mid :

[0051]

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

[0053] In some embodiments, including:

[0054] Optimize the objective function of the intermediate nodes:

[0055]

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

[0057] In some embodiments, including:

[0058] Interpolate opacity, position, tangent, and scale vectors.

[0059] In some embodiments, the merging of the plurality of segmented scenes includes:

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

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

[0062] By dividing a large-scale scene into blocks, a number of block scenes are obtained, wherein there is an overlapping area between two adjacent block scenes; a median partitioning algorithm is used to recursively create a bounding box, spatially divide the block scene, and generate a BVH tree; a node in the LOD tree is dynamically selected to generate an LOD structure according to the granularity of the node corresponding to the camera distance, so as to achieve a close-up or mid-range scene performance; based on the LOD tree, a breadth-based traversal binary tree method is used, and a preset proportion of leaf nodes of the LOD tree are used to generate a hierarchical level of detail HLOD, so as to achieve a distant scene performance; a number of block scenes are merged; and rendering efficiency can be improved while maintaining visual quality. BRIEF DESCRIPTION OF THE DRAWINGS

[0063] The embodiments of the present invention are further described below with reference to the accompanying drawings:

[0064] Figure 1 A schematic diagram of the implementation flow of a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering provided in an embodiment of the present invention;

[0065] Figure 2 A schematic diagram of the structure of an electronic device provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0066] In order to make the purpose, technical solutions and advantages of the present invention clearer, the present invention will be further described in detail below in conjunction with the accompanying drawings. The described embodiments should not be regarded as limiting the present invention. All other embodiments obtained by ordinary technicians in the field without making creative work are 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, but it will be understood that “some embodiments” may be the same subset or different subsets of all possible embodiments and may be combined with each other without conflict.

[0068] If similar descriptions of "first\second\third" appear in the application documents, the following instructions are added. In the following description, the terms "first\second\third" involved are only used to distinguish similar objects and do not represent a specific order for the objects. It can be understood that "first\second\third" can be interchanged in a specific order or sequence where 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 those commonly understood by those skilled in the art 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, an embodiment of the present invention provides a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering, and 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, a tablet computer, a desktop computer, a set-top box, a mobile device (for example, a mobile phone, a portable music player, a personal digital assistant, a dedicated messaging device, a portable gaming device), and can also be implemented as a server. The server can be an independent physical server, or a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides 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 networks (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 may be implemented by a processor of an electronic device calling a program code, wherein the program code may be stored in a computer storage medium.

[0072] The embodiment of the present invention provides a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering. Figure 1 A schematic diagram of the implementation flow of a large-scale scene organization and dynamic scheduling method based on two-dimensional Gaussian sputtering provided in an embodiment of the present invention is shown in FIG. Figure 1 As shown, including:

[0073] Step S1: Divide the large-scale scene into blocks to obtain a plurality of block scenes, wherein there is an overlapping area between two adjacent block scenes;

[0074] In some embodiments, the step S1 includes:

[0075] Step S11: Divide the point cloud of the large-scale scene into blocks evenly according to the physical positions;

[0076] Step S12: creating a bounding box, and using the bounding box to capture the blocks to obtain a plurality of block scenes.

[0077] In an embodiment of the present invention, the point cloud of a large-scale scene is evenly divided into blocks according to physical positions. For example, the point cloud of a large-scale scene can be evenly divided into eight blocks. Then a bounding box is created, and the corresponding blocks in the large-scale scene are captured by the bounding box to obtain a plurality of block scenes. When performing the block division, the area overlap between the block scenes is used to achieve a certain degree of visual smooth transition between the block scenes.

[0078] Step S2: Use the median partitioning algorithm to recursively create a bounding box, perform spatial segmentation on the block scene, and generate a BVH tree;

[0079] In some embodiments, the step S2 comprises:

[0080] Step S21: Calculate the two-dimensional mean position of each Gaussian disk in the block scene, 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: dividing the object set according to the median of the projection of the two-dimensional mean positions of all 2D Gaussian disks to obtain two subsets;

[0082] Step S23: 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 a preset threshold;

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

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

[0085] In some embodiments, the step S24 includes:

[0086] Step S241: when the number of 2D Gaussian disks in the subset is less than a preset threshold, stop the recursion and take 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, wherein the intermediate node contains a reference to its child node;

[0088] Step S243: constructing a tree structure of a BVH tree based on the intermediate nodes and leaf nodes.

[0089] In an embodiment of the present invention, intermediate nodes are non-leaf nodes in a BVH tree, which do not directly contain 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 the 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 surround all objects in its child nodes.

[0090] In some embodiments, the step S242 includes:

[0091] Step S2421: Position merging:

[0092]

[0093] 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 usually determined by the importance of the child node;

[0094] Step S2422: merging tangent vectors:

[0095]

[0096] In the formula, 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;

[0097] Step S2423: Scaling vector merging:

[0098]

[0099] 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, and ω is the weight of the ith child node.

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

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

[0102] In some embodiments, step S3 includes:

[0103] Step S31: Based on the BVH tree, create an LOD tree node for each node;

[0104] Step S32: 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;

[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, wherein 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 an embodiment 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), which are the most detailed representations in the LOD tree, which means that at the bottom layer of the LOD tree, each node contains the original object 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 the 2D Gaussian disk attributes of the child nodes are combined by weighted averaging to form a new 2D Gaussian disk, which can ensure the visual continuity and consistency of the LOD tree, while allowing models of different complexities to be used at different distances.

[0107] In some embodiments, the step S33 includes:

[0108] Step S331: Perform weighted averaging on the 2D Gaussian disk position of each child node to obtain the position μ of the middle node mid :

[0109]

[0110] In the formula, μ j is the 2D Gaussian disk position of the jth child node, and α is the corresponding weight, which is usually determined by the quality of the child node.

[0111] Step S332: Calculate the tangent vector of the middle node using the weighted average method

[0112]

[0113] In the formula, is the tangent of the jth child node, and β is the corresponding weight;

[0114] Step S333: Perform weighted averaging on the scaling vectors of each child node to obtain the scaling vector of the middle node.

[0115]

[0116] In the formula, is the scaling vector of the jth child node, and γ is the corresponding weight;

[0117] Step S334: Perform weighted average on the opacity of each child node to obtain the opacity of the middle node. mid :

[0118]

[0119] In the formula, O j is the opacity of the jth 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] 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.

[0123] In the embodiment of the present invention, the position, tangent vector, scaling vector, opacity and color information of the 2D Gaussian disk of the child node are combined by weighted averaging to form a new 2D Gaussian disk. The weight of the weighted average is usually determined based on the visual importance of the child node or the distance from the observer. For opacity, it is necessary to ensure that the opacity of multiple 2D Gaussian disks does not exceed 1.

[0124] In some embodiments, including:

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

[0126]

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

[0128] In the embodiment of the present invention, an objective function is defined to minimize the error or difference of the 2D Gaussian disk of the intermediate node.

[0129] In some embodiments, including:

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

[0131] In the embodiment of the present invention, the opacity, position, tangent vector, and scaling vector may be interpolated:

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

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

[0134]

[0135] Where t is time. Through the above interpolation processing, a smooth transition between different levels can be guaranteed.

[0136] Step S4: dynamically selecting nodes in the LOD tree to generate an LOD structure according to the granularity of the node corresponding to the camera distance, so as to achieve a close-up or mid-range scene performance;

[0137] In the embodiment of the present invention, the target granularity threshold τ is set according to the distance between the camera and the node. ∈ , we can define the node granularity ∈(n)=max(AABB(n)), where AABB(n) is the bounding box of node n. If the granularity ∈(n) of a node is less than the target granularity threshold τ ∈ , the 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 nodes that are closer to the camera, a higher-detail LOD structure is selected for rendering to ensure that objects in the near and mid-range have sufficient details and clarity, thereby providing richer visual information when the user observes these objects.

[0139] Step S5: Based on the LOD tree, a breadth-based 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 representation.

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

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

[0142] Step S6: Merge several block scenes.

[0143] In some embodiments, step S6 includes:

[0144] Step S61: merging the 2D Gaussian disk of the current block scene 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 by spatial position matching.

[0145] In the embodiment of the present invention, each block scene may have different degrees of differences in image effects after independent training, especially there are partial overlapping areas between adjacent block scenes, which will affect the consistency of the whole scene. Therefore, it is necessary to merge several block scenes to ensure the continuity and consistency of visual effects. In each block scene, the 2D Gaussian disk of the current block scene is merged with the 2D Gaussian disk inherited by the adjacent block scene. It is ensured that the boundary area of ​​the current block scene can be seamlessly connected with the 2D Gaussian disk of the adjacent block scene to form visual continuity. In 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 to avoid inconsistent visual effects in the overlapping area. It is understandable that, no matter in the case of close view, mid-view or long view, when the visible area disappears, it is necessary to dynamically unload the data of the corresponding partition to release memory and reduce resource occupation.

[0146] In summary, by creating a bounding box, a large-scale scene is divided into blocks to obtain several block scenes, wherein there is an overlapping area between two adjacent block scenes; a median partitioning algorithm is used to recursively create a bounding box, spatially divide the block scene, and generate a BVH tree; the nodes in the LOD tree are dynamically selected to generate an LOD structure according to the granularity of the node corresponding to the camera distance, so as to achieve the scene performance of the close or medium shot; based on the LOD tree, a breadth-based traversal binary tree method is used, and a preset proportion of leaf nodes of the LOD tree are used to generate a hierarchical level of detail HLOD, so as to achieve the scene performance of the distant shot; several block scenes are merged; and the rendering efficiency can be improved while maintaining the visual quality.

[0147] It should be noted that, in the embodiment of the present invention, if the above-mentioned dynamic scheduling method is implemented in the form of a software function module and sold or used as an independent product, it can also be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the embodiment of the present invention can be essentially or partly reflected in the form of a software product that contributes to the prior art. The computer software product is stored in a storage medium, including several instructions to enable a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the methods described in each embodiment of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as a U disk, a mobile hard disk, a read-only memory (ROM, ReadOnly Memory), a magnetic disk or an optical disk. In this way, the embodiment of the present invention is not limited to any specific combination of hardware and software.

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

[0149] An embodiment of the present invention provides an electronic device; Figure 2 A schematic diagram of the structure of an electronic device provided by an embodiment of the present invention is shown in FIG. Figure 2 As 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. The communication bus 402 is configured to realize the connection and communication between these components. 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 embodiment.

[0150] It should be noted that the description of the above storage medium and electronic device embodiments is similar to the description of the above method embodiments, and has similar beneficial effects as the method embodiments. For technical details not disclosed in the storage medium and device embodiments of the present invention, please refer to the description of the method embodiments of the present invention for understanding.

[0151] It should be understood that "one embodiment" or "an embodiment" mentioned throughout the specification means that specific features, structures or characteristics related to the embodiment are included in at least one embodiment of the present invention. Therefore, "in one embodiment" or "in an embodiment" appearing throughout the specification does not necessarily refer to the same embodiment. In addition, these specific features, structures or characteristics can be combined in one or more embodiments in any suitable manner. It should be understood that in various embodiments of the present invention, the size of the serial number of the above-mentioned processes does not mean 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 embodiment of the present invention. The serial numbers of the above-mentioned embodiments of the present invention are only for description and do not represent the advantages and disadvantages of the embodiments.

[0152] It should be noted that, in this article, the terms "include", "comprises" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, object or device including a series of elements includes not only those elements, but also includes other elements not explicitly listed, or also includes elements inherent to such process, method, object or device. In the absence of further restrictions, an element defined by the sentence "comprises a ..." does not exclude the existence of other identical elements in the process, method, object or device including the element.

[0153] In the 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 schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, 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 can be through some interfaces, and 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, and the components displayed as units may or may not be physical units; they may be located in one place or distributed on multiple network units; some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.

[0155] In addition, all functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may be separately used as a unit, or two or more units may be integrated into one unit; the above-mentioned integrated units may be implemented in the form of hardware or in the form of hardware plus software functional units.

[0156] A person skilled in the art can understand that all or part of the steps of implementing the above method embodiment can be completed by hardware related to program instructions, and the aforementioned program can be stored in a computer-readable storage medium. When the program is executed, it executes the steps of the above method embodiment; and the aforementioned storage medium includes: mobile storage devices, read-only memories (ROM, Read On ly Memory), disks or optical disks, etc. Various media that can store program codes.

[0157] Alternatively, if the above-mentioned integrated unit of the present invention is implemented in the form of a software function module and sold or used as an independent product, it can also be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the embodiment of the present invention can be essentially or partly reflected in the form of a software product, which is stored in a storage medium and includes several instructions for a controller to execute all or part of the methods described in various embodiments of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as mobile storage devices, ROMs, magnetic disks or optical disks.

[0158] The above is only an embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art can easily think of changes or substitutions within the technical scope disclosed by the present invention, which should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention should be based on 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; 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 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; The tree structure of the BVH tree is constructed using the bounding boxes created in the recursive process as nodes.

4. The method according to claim 3, characterized in that 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, a tree structure of the BVH tree is constructed.

5. The method according to claim 4, characterized in that 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 usually 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, and ω is the weight of the ith child node.

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

7. The method according to claim 6, 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, and α is the corresponding weight, which is usually determined by the quality of the child node. Use weighted average method to calculate the tangent vector of the middle node 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.

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

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

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