GIM three-dimensional model fusion method

Abstract

The invention discloses a GIM three-dimensional model fusion method. The method comprises the following steps: firstly, constructing and initializing a fusion scene containing grids, materials, textures, a node array, a quintuple grid relation table and an octree array; extracting data such as identification, grids and material texture of each three-dimensional file of the GIM model, constructing a new node, and matching and assigning a material texture index number; then counting grid parameters to construct a quintuple index, combining octree triangle inspection to realize grid multiplexing or newly adding, and completing node grid index assignment and addition; and repeating the operation until all the files are processed, and outputting the fusion model. According to the method, through standardized framework construction, index multiplexing and combined grid detection, data redundancy is reduced, hardware resource occupation is reduced, grid matching efficiency is improved, model information integrity is kept, the problem of rendering lagging is solved, and efficient lightweight data support is provided for value analysis in the power industry.

Description

Technical Field

[0001] This invention belongs to the field of computer application technology, specifically a GIM three-dimensional model fusion method. Background Technology

[0002] With the deepening of digital transformation in the power industry, the demand for 3D visualization technology in core businesses such as power grid planning and design, equipment operation and maintenance management, and engineering construction supervision is becoming increasingly urgent. GIM (Power Grid Information Model), as an industry-standard data exchange format, integrates key information such as the geometric structure, attribute parameters, and spatial relationships of power grid equipment, providing unified support for cross-platform and cross-system data interoperability and sharing. It has become the core carrier for 3D power grid modeling, business collaborative analysis, and full lifecycle management, effectively promoting the transformation and upgrading of smart grids from traditional operation and maintenance to digital and intelligent operation and maintenance.

[0003] However, the existing 3D data organization of GIM models has significant flaws. A large amount of 3D model data is stored independently as discrete files, each carrying redundant data such as meshes, materials, and textures. During 3D rendering, the system needs to load multiple discrete files simultaneously and repeatedly parse similar data. This not only significantly increases the I / O overhead of data reading but also leads to excessive consumption of hardware computing and storage resources, resulting in reduced rendering frame rates and sluggish operation responses. This problem severely impacts the smoothness of 3D visualization and the user experience, hindering the efficient application of GIM models in complex scenarios within the power industry. A targeted technical solution is urgently needed to address the rendering efficiency bottleneck caused by discrete files. Summary of the Invention

[0004] The purpose of this invention is to provide a GIM 3D model fusion method to solve the following technical problems mentioned in the background art: GIM models contain a large number of discrete 3D model data files, and the numerous discrete 3D files can easily cause 3D rendering lag.

[0005] To solve the above-mentioned technical problems, the technical solution adopted by the present invention is as follows: A GIM 3D model fusion method includes the following steps: A. Construct the blended scene, which includes a mesh array, material array, texture array, node array, quintuple mesh relationship table, and octree array; initialize the blended scene; B. Extract all 3D model files from the GIM model, and extract the model identifier, model name, mesh, material lighting, texture, and transformation matrix of each 3D model file; C. Construct a new node, assign the model identifier, model name and transformation matrix to the new node, and initially set the material index and mesh index of the new node to empty; D, obtain the material light index number by matching the material light in the material array, obtain the texture index number by matching the texture in the texture array, and assign the material index to the new node based on the material light index number and the texture index number; E represents the three-axis spans sx, sy, sz, the number of grid points np, and the number of triangles nt of the statistical grid, and constructs a quintuple as the grid feature index; where the quintuple includes sx, sy, sz, np, and nt. F, query the quintuple grid relationship table using quintuples as keys: If the quintuple grid relation table contains at least one octree associated with the quintuple, then perform a triangle check on each associated octree: if all triangles in the grid exist in a certain octree, then reference the grid index corresponding to that octree. If no octree meets the conditions, add the grid as a new grid to the end of the grid array and get the grid index. Create a new octree and add it to the octree array. Establish the association between the quintuple and the new grid in the quintuple grid relationship table and insert each triangle in the new grid into the newly created octree. G assigns a grid index to a new node based on the grid index and adds the new node to the node array; H, repeat the BG step until all 3D model files have been processed, and output the 3D model corresponding to the fused scene.

[0006] Furthermore, the material light is a quaternion, which includes diffuse light, ambient light, specular light, and self-emission. Diffuse light, ambient light, specular light, and self-emission are all quadruples r, g, b, a; r, g, b, and a are the red, green, blue, and transparency color components, respectively. The texture is a tuple consisting of a two-dimensional array of image pixels and texture coordinates wrapped around a marker; The material is a binary combination of material light and texture.

[0007] Furthermore, the grid index is a quintuple of x-axis span, y-axis span, z-axis span, number of grid points, and number of grid triangles; the grid is defined as a binary tuple of a set of three-dimensional points and a set of triangles, where each triangle in the triangle set is formed by three indices in the point set.

[0008] Furthermore, in step F, the specific steps for the octree to perform the triangle check are as follows: Starting from the root node of the octree, compare the triangles within the current node. If a matching triangle exists, the check is successful, and the process continues to the next triangle. If the current node fails the check, and the range of its child nodes is not smaller than the range of the triangle, then recursively check the child nodes. If the range of its child nodes is smaller than the range of the triangle, the check for the triangle is deemed to have failed.

[0009] Furthermore, in step F, the specific steps for inserting the triangle into the newly created octree are as follows: Starting from the root node of the octree, triangles are inserted. If the number of triangles contained in the current node reaches the threshold, the current node is divided into subgrids. If a child node completely contains a triangle, the triangle is assigned to that child node; otherwise, it is retained in the current node. If the number of triangles contained in a child node reaches the threshold, the division and triangle assignment operations are recursively performed on that child node until all triangles are inserted.

[0010] Furthermore, in step D, if there is no index corresponding to the material light in the material array, the material light is appended to the end of the material array and the index is obtained; if there is no index corresponding to the texture in the texture array, the texture is appended to the end of the texture array and the index is obtained.

[0011] Furthermore, the data for each node in the node array consists of a quintuple of model name, model identifier, mesh index, material index, and transformation matrix.

[0012] A GIM 3D model fusion system, used to implement the method described in any of the preceding aspects, comprising: The scene construction module is used to build and initialize the merged scene. The file extraction module is used to extract all 3D model files in the GIM model, and extract the model identifier, model name, mesh, material light, texture and transformation matrix of each 3D model file respectively; The node construction module is used to construct new nodes, assign model identifier, model name and transformation matrix to the new node, and initially set the material index and mesh index of the new node to empty; The material and texture processing module is used to obtain the material light index number by matching the material light in the material array, obtain the texture index number by matching the texture in the texture array, and assign a material index to the new node based on the material light index number and the texture index number. The grid index construction module is used to count the three-axis spans sx, sy, sz, the number of grid points np, and the number of triangles nt of the grid, and construct a quintuple of sx, sy, sz, np, nt as the grid feature index. The grid processing module is used to query the quintuple grid relationship table using quintuples as keys. If the quintuple grid relation table contains at least one octree associated with the quintuple, then perform a triangle check on each associated octree: if all triangles in the grid exist in a certain octree, then reference the grid index corresponding to that octree. If no octree meets the conditions, add the grid as a new grid to the end of the grid array and obtain the grid index. Create a new octree and add it to the octree array. Establish the association between the quintuple and the new grid in the quintuple grid relationship table, and insert each triangle in the new grid into the newly created octree.

[0013] The node generation module is used to assign a grid index to a new node based on the grid index and add the new node to the node array; The output module is used to output the 3D model corresponding to the fused scene.

[0014] A GIM 3D model fusion device includes a memory and a processor. The memory stores a computer program, and the processor executes the program to implement the GIM 3D model fusion method as described in any of the preceding claims.

[0015] Compared with the prior art, the present invention has the following beneficial effects: The GIM 3D model fusion method of this invention achieves dual optimization through standardized data framework construction, core data extraction and unified processing, and by leveraging material / texture index reuse mechanisms, mesh quintuple feature index filtering, and octree space partitioning verification technology: On the one hand, by accurately identifying and indexing duplicate material, texture, and mesh data, it reduces the large amount of data redundancy caused by discrete files in the GIM model, significantly reducing the overall data volume and hardware resource consumption of the model; on the other hand, it transforms the comparison of massive mesh geometric data into a combination of preliminary screening of quintuple core parameters and precise octree verification, avoiding the unnecessary overhead of full data traversal comparison and significantly accelerating the efficiency of mesh duplication detection and matching. The final output fused model not only maintains the integrity of the core information of all original models, but also solves the 3D rendering lag problem caused by discrete files, improving rendering smoothness and user experience, and providing efficient and lightweight data support for value analysis and mining for users in the power industry. Attached Figure Description

[0016] Figure 1 This is a schematic diagram of the conceptual structure of the present invention; Figure 2 This is a schematic diagram of the process of the present invention; Detailed Implementation

[0017] 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 embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0018] Example 1: A GIM 3D model fusion method, such as Figure 2 As shown, it includes the following steps: A, such as Figure 1 as well as Figure 2 As shown, a blended scene is constructed, which includes a mesh array, a material array, a texture array, a node array, a quintuple mesh relationship table, and an octree array; the blended scene is then initialized.

[0019] This step is used to build the basic data framework for GIM 3D model fusion, providing a unified carrier for the storage, association and processing of subsequent material, mesh, node and other data, clarifying the composition of the core components required in the fusion process, and ensuring that all subsequent data operations have a standardized execution environment.

[0020] Specifically, the core components of the fusion scene are first defined, including a mesh array for storing all mesh data, a material array for storing material information, a texture array for storing textures, a node array for storing core model association information, a quintuple mesh relationship table for establishing mesh indexes and mesh correspondences, and an octree array that corresponds one-to-one with the mesh array. Then, all components are initialized to an empty state or default initial values, and logical correspondences between components are established, laying the structural foundation for subsequent data entry, matching, and association.

[0021] This step, through a unified scene framework and initialization operations, provides a standardized entry point for subsequent data sharing and indexing of materials and meshes, avoiding the confusion caused by discrete data storage.

[0022] B, such as Figure 1 as well as Figure 2 As shown, all 3D model files in the GIM model are extracted, and the model identifier, model name, mesh, material light, texture and transformation matrix of each 3D model file are extracted respectively.

[0023] This step is used to obtain the raw data required for fusion, transforming the discrete 3D model files in the GIM model into a core data set that can be processed uniformly, providing direct operation objects for subsequent material deduplication and mesh matching.

[0024] Specifically, the process iterates through all discrete 3D model files contained in the GIM model. For each file, core data such as model identifier, model name, mesh, material lighting, texture, and transformation matrix are precisely extracted. Irrelevant and redundant information is discarded to form a standardized raw data list, ensuring data consistency in subsequent processing. The model identifier is used to distinguish different models; the mesh contains a set of 3D points and triangles; material lighting determines the optical properties of the materials; texture determines the surface texture of the materials; and the transformation matrix determines the model's spatial position and orientation.

[0025] This step avoids the I / O overhead of repeatedly reading discrete files by centrally extracting key data, thus reducing the unnecessary costs of data transmission and processing.

[0026] C, such as Figure 1 as well as Figure 2 As shown, a new node is constructed, and the model identifier, model name, and transformation matrix are assigned to the new node. Initially, the material index and mesh index of the new node are set to empty.

[0027] This step is used to create a unified data carrier in the fusion scene for each original 3D model, realize the logical mapping between the original discrete model and the fusion scene, and ensure that the core information of each model has a clear storage location and association method in the fusion scene.

[0028] Specifically, according to the node definition of the fusion scene, a new node is constructed for each extracted 3D model file, and the model identifier, model name and transformation matrix extracted in step B are directly assigned to the new node; at the same time, since the material index and mesh index need to be determined through subsequent matching, they are temporarily left empty to ensure that the node structure is consistent and the information to be filled is clear, and to reserve an interface for subsequent material and mesh index association.

[0029] The standardized node format in this step makes the subsequent referencing and management of material indexes and mesh indexes more standardized, avoids duplicate storage caused by differences in node structure, and effectively reduces data redundancy at the node level.

[0030] D, such as Figure 2 As shown, the material light index number is obtained by matching the material light in the material array, and the texture index number is obtained by matching the texture in the texture array. The material index number and the texture index number are used to assign a material index to the new node.

[0031] This step is used to enable the sharing and reuse of material data, avoid the duplicate storage of the same material, and establish a precise association between materials and nodes. It is the core step to reduce material data redundancy.

[0032] Specifically, for the material light extracted in step B, a traversal and matching process is performed in the initialized material array. If an identical material light exists, its corresponding index is directly referenced; otherwise, the material light is appended to the end of the material array, and a new index is obtained. Similarly, the same matching and index retrieval logic is performed on the texture array. Finally, a unique material index is assigned to the new node by combining the material light index number and the texture index number, establishing the association between the node and the corresponding material.

[0033] This step uses an index reuse mechanism so that the same material light and texture do not need to be stored repeatedly in the material array and texture array. They can be shared simply by using an index reference, which greatly reduces data redundancy at the material level.

[0034] E, such as Figure 2 As shown, the three-axis spans sx, sy, sz, the number of grid points np, and the number of triangles nt of the statistical grid are used to construct a quintuple (sx, sy, sz, np, nt) as the grid feature index.

[0035] This step is used to establish core feature identifiers for the grid, transforming the comparison of massive grid data into the comparison of core parameters, providing a basis for the subsequent rapid location of potential duplicate grids, and is a key prerequisite for accelerating the efficiency of grid comparison.

[0036] Specifically, the core parameters of the grid data extracted in step B are statistically analyzed: the span of the grid along the x, y, and z axes, the number of grid points, and the number of triangles are calculated. These five key parameters are combined into a quintuple, which serves as the unique index of the grid. This quintuple encapsulates the core geometric features of the grid, enabling rapid differentiation between different grids and providing an efficient comparison basis for subsequent grid duplication detection.

[0037] This step condenses massive amounts of grid points and triangle data into five key parameters using a quintuple grid feature index, avoiding the need for a full comparison of the massive geometric data in the future. This significantly reduces the amount of raw data for grid comparison and greatly improves the efficiency of the initial grid screening.

[0038] F, such as Figure 2 As shown, query the quintuple grid relationship table using quintuples as keys: If the quintuple grid relation table contains at least one octree associated with the quintuple, then perform a triangle check on each associated octree: if all triangles in the grid exist in a certain octree, then reference the grid index corresponding to that octree. If no octree meets the conditions, add the grid as a new grid to the end of the grid array and obtain the grid index. Create a new octree and add it to the octree array. Establish the association between the quintuple and the new grid in the quintuple grid relationship table, and insert each triangle in the new grid into the newly created octree.

[0039] This step is used to achieve duplicate detection and shared reuse of the grid, or to create new grids and octrees. It is the core step to reduce grid data redundancy and accelerate grid comparison efficiency.

[0040] Specifically, this step uses the quintuple constructed in step E as the key value to query the quintuple grid relationship table. If there is at least one octree associated with the quintuple in the relationship table, then a triangle check is performed on each associated octree: starting from the root node of the octree, all triangles in the grid are recursively compared. If all triangles exist in a certain octree, it means that the grid is completely consistent with the grid corresponding to the octree, and the index number of the grid is directly referenced. If there is no associated octree in the relation table, or if the triangle check of all associated octrees fails, then the grid is added as a new grid to the end of the grid array and the grid index is obtained. A new octree is created and added to the octree array. The association between the quintuple and the new grid is established in the quintuple grid relation table. Then, each triangle in the new grid is inserted into the newly created octree according to the octree partitioning rules. Starting from the root node, if the number of triangles in a node reaches the threshold (the default value is 50-100 triangles, which can be customized by the user according to the hardware configuration; or an adaptive threshold can be used to dynamically adjust according to the current grid triangle density), then the child nodes are recursively partitioned until all triangles are inserted.

[0041] This step quickly filters out potential duplicate grids by querying the 5-tuple grid index, avoiding a full comparison of all grids, significantly reducing invalid comparisons, and accelerating the initial screening efficiency of grid duplication detection. Meanwhile, the octree triangle checking mechanism utilizes spatial partitioning characteristics to limit triangle comparisons to specific nodes, avoiding traversing and comparing all triangles, significantly improving the efficiency of accurate grid matching. Simultaneously, duplicate grids are shared by referencing existing grid indexes, eliminating the need to repeatedly store grid data and octrees, greatly reducing data redundancy at the grid level and lowering hardware resource consumption.

[0042] G, such as Figure 1 as well as Figure 2 As shown, a new node is assigned a grid index based on the grid index, and the new node is added to the node array.

[0043] This step is used to complete the construction of the new node, integrating the core association information of each model into the fusion scenario, and realizing the unified management of discrete model information.

[0044] Specifically, the mesh index obtained in step F is assigned to the mesh index of the new node, and the model identifier, model name, transformation matrix, material index and mesh index of the node are completed. Then the complete new node is added to the node array to realize the centralized storage of all processed model nodes, ensuring that the information of each model has a unique corresponding storage location and complete association in the fusion scene.

[0045] This step avoids the decentralized management of discrete node information by building and centrally storing the complete node structure.

[0046] H, such as Figure 2 As shown, repeat the BG step until all 3D model files have been processed, and output the 3D model corresponding to the fused scene.

[0047] Steps B through G are executed iteratively, performing data extraction, node construction, material matching, mesh processing, and node refinement on each 3D model file in the GIM model to ensure that every discrete model is included in the fusion scene. Once all models have been processed, all components in the fusion scene, including node arrays, mesh arrays, material arrays, and texture arrays, are integrated to output a unified 3D model. This model contains the core information of all the original models, and redundancy is eliminated through data sharing. By batch fusion processing of all discrete models, previously scattered and repetitive material and mesh data are globally shared through index references, reducing data redundancy in the entire GIM model and significantly decreasing the overall data volume and hardware resource consumption.

[0048] In summary, this GIM 3D model fusion method achieves dual core optimizations through standardized data framework construction, core data extraction and unified processing, and by leveraging material / texture index reuse mechanisms, mesh quintuple feature index filtering, and octree spatial partitioning verification techniques. Firstly, by accurately identifying and indexing duplicate materials, textures, and mesh data, it reduces the significant data redundancy caused by discrete files in the GIM model, substantially decreasing the overall model data volume and hardware resource consumption. Secondly, it transforms the comparison of massive mesh geometric data into a combined mode of preliminary screening using quintuple core parameters and precise octree verification, avoiding the unnecessary overhead of full data traversal and comparison, and significantly accelerating mesh duplication detection and matching efficiency. The final fused model not only maintains the integrity of the core information of all original models but also solves the 3D rendering stuttering problem caused by discrete files, improving rendering smoothness and user experience, and providing efficient and lightweight data support for value analysis and mining for power industry users.

[0049] The following case study will further illustrate the implementation process and effects of the GIM 3D model fusion method. The details are as follows: In a 220kV smart substation 3D digitization project in a certain region, the original GIM model data package handed over by the design institute contained a total of 162 independent 3D model files, corresponding to equipment such as transformers, disconnect switches, voltage transformers, surge arresters, and busbar support structures within the substation. Upon verification, 28 sets of identical "XXX-XXX" type post insulators were found within the substation, used for busbar support. In the original GIM deliverables, these 28 sets of insulators were stored as 28 independent model files, each containing the same mesh data, material lighting, and textures.

[0050] Applying the method of this invention, the system first executes step A to construct and initialize the fused scene. Subsequently, the system executes steps B through H, traversing and processing all model files. When processing the first "XXX-XXX" insulator file, the system extracts its data and constructs a quintuple mesh index (e.g., (0.3, 2.2, 0.3, 1200, 2300)). Since it is the first occurrence, the system stores its mesh, material, and texture in the corresponding arrays and builds an octree index for it, ultimately generating a complete node.

[0051] When the system processes the subsequent 27 insulator files of the same type, the process demonstrates its core optimization effect. In step D, the material and texture are identified as duplicates, and the existing index number is directly reused. In step F, the existing octree is retrieved through the quintuple index, and after confirming geometric consistency through triangle checking, the system directly references the existing mesh index, avoiding the duplicate storage of these 27 identical mesh data.

[0052] By repeatedly executing this method, the system completes the processing of all files. In the final output fused scene, the node array retains 162 independent records, ensuring the integrity of the location and identification information of each device instance. However, effective compression is achieved at the data storage level: the mesh data, material data, and textures corresponding to 28 sets of insulators of the same model are each stored in only one copy in the corresponding array of the fused scene.

[0053] Quantitative analysis shows that, in this embodiment, the fused model reduces the total amount of geometry and textures in video memory by approximately 18% to 25% compared to the original discrete files. After being imported into the substation 3D visualization platform, the fused model was tested on mainstream workstation hardware configurations, and the following performance improvements were observed: scene loading time was shortened by approximately 30% due to the reduction in the number of files to be parsed and the elimination of duplicate data loading; in a typical panoramic view including all devices, the rendering frame rate achieved a stable improvement of 15% to 20% due to the merging of rendering calls and the reduction in data volume, effectively alleviating rendering stuttering in large-scale scenes, while fully maintaining the independent selectability and spatial accuracy of each device.

[0054] Example 2: This embodiment is a further supplement and explanation based on Embodiment 1. Specifically, in this embodiment, the material light is a quadruple (diffuse reflection light, ambient light, specular reflection light, and self-illumination). Diffuse light, ambient light, specular light, and self-emission are all quadruples (r, g, b, a), where r, g, b, and a are the red, green, blue, and transparency color components, respectively. The texture is a binary tuple (a two-dimensional array of image pixels and texture coordinate wrapping markers); The material is a binary (material light, texture).

[0055] In a preferred embodiment, the grid index is a quintuple (x-axis span, y-axis span, z-axis span, number of grid points, number of grid triangles); the grid is defined as a binary tuple (three-dimensional point set, triangle set), wherein each triangle in the triangle set is formed by three indices in the point set.

[0056] Specifically, by defining material-related data in a hierarchical and quantitative manner, material light is decomposed into four-dimensional quadruples: diffuse light, ambient light, specular light, and self-emission. Each light component is then precisely described by a (r, g, b, a) quadruple, achieving a quantifiable expression of optical properties. Texture is defined as a two-dimensional array of image pixels and a texture coordinate wrapped marker in a binary form, clearly defining the core data and application rules of the texture. The material integrates material light and texture to form a complete material data unit. Mesh-related data is feature-condensed and structurally defined. The mesh index is extracted using a five-tuple (x-axis span, y-axis span, z-axis span, number of mesh points, number of mesh triangles) to extract the core geometric features of the mesh. The mesh is defined as a binary tuple of a three-dimensional point set and a triangle set, and the triangles are clearly associated through the point set index, allowing for precise traceability and comparison of the mesh's geometric composition. All definitions adopt structured array or tuple forms to ensure that the data has a unified storage, retrieval, and comparison logic.

[0057] This embodiment transforms the determination of material and mesh similarity from fuzzy qualitative to quantitative comparison through a standardized data structure. This avoids misjudgments or omissions caused by inconsistent data formats, ensuring that identical materials and meshes can be accurately identified and reused through indexing, further reducing data redundancy at the material and mesh levels. Simultaneously, the quantized tuple format eliminates the need to parse complex abstract information for data comparison, requiring only one-by-one verification of the structured array. This significantly reduces the computational complexity of material matching, mesh index lookup, and triangle verification, accelerating overall data processing efficiency. Furthermore, the unified data structure reduces format conversion overhead during data storage and retrieval, resulting in more organized data organization in the fusion model, further reducing hardware resource consumption, improving the smoothness of 3D rendering, and better adapting to the application scenarios of GIM models in the power industry.

[0058] Example 3: This embodiment is a further supplement and explanation based on Embodiment 1. Specifically, in this embodiment, the specific steps for performing the triangle check on the octree are as follows: Starting from the root node of the octree, compare the triangles within the current node. If a matching triangle exists, the check is successful, and the process continues to the next triangle. If the current node fails the check, and the range of its child nodes is not smaller than the range of the triangle, then recursively check the child nodes. If the range of its child nodes is smaller than the range of the triangle, the check for the triangle is deemed to have failed.

[0059] Specifically, starting from the root node of the octree, the process prioritizes comparing the triangles stored in the current node. If a completely matching triangle is found, the verification is successful, and the process proceeds directly to the next triangle. If the current node does not match the target triangle, the process first determines the size relationship between the spatial range of the child node and the range of the triangle. If the range of the child node is not smaller than the range of the triangle, it means that the triangle may exist in the child node, and the process recursively enters the child node to repeat the above comparison process. If the range of the child node is smaller than the range of the triangle, it means that the triangle cannot exist in any level node of the current octree, and the verification of the triangle is directly determined to be unsuccessful, terminating the subsequent verification of the triangle.

[0060] This embodiment avoids indiscriminate traversal of all nodes in the octree by using a check logic that prioritizes parent nodes before child nodes and performs range prediction followed by recursion. This significantly reduces the amount of unnecessary computation in triangle matching and greatly accelerates the accuracy and efficiency of mesh duplication detection. At the same time, strict range adaptation rules ensure the accuracy of triangle checking, avoiding misjudgment or omission of duplication due to ambiguity in the check logic. It ensures that only completely identical meshes can be referenced and reused, further enhancing the reduction of mesh data redundancy and reducing hardware storage and computing resource consumption. This provides a key guarantee for the efficient rendering of the fusion model.

[0061] Example 4: This embodiment is a further supplement and explanation based on Embodiment 1. Specifically, in step F, the specific steps for inserting the triangle into the newly created octree are as follows: Starting from the root node of the octree, triangles are inserted. If the number of triangles contained in the current node reaches the threshold, the current node is divided into subgrids. If a child node completely contains a triangle, the triangle is assigned to that child node; otherwise, it is retained in the current node. If the number of triangles contained in a child node reaches the threshold, the division and triangle assignment operations are recursively performed on that child node until all triangles are inserted.

[0062] Specifically, in this embodiment, the root node of the octree is used as the insertion starting point. The triangle is first temporarily stored in the current node. The number of triangles contained in the current node is counted in real time. If the number reaches a preset threshold, the node is divided into sub-mesh. Then, the fit relationship between each triangle and the child node space is determined. Only when the child node space completely contains a triangle is the triangle assigned to the child node. If the child node space cannot completely contain the triangle, the triangle is kept in the current node. If the number of triangles contained in subsequent child nodes reaches the preset threshold, the recursive operation of sub-node division and triangle assignment is repeated until all triangles are inserted and the triangle load of each node is within a reasonable range.

[0063] This embodiment establishes a spatially hierarchical and load-balanced structure for the octree through a standardized insertion process. Triangles are stored centrally according to spatial range, avoiding invalid traversals during subsequent checks caused by data dispersion. This provides an efficient data retrieval foundation for grid duplication detection and significantly accelerates the efficiency of subsequent octree triangle checks. Simultaneously, threshold-triggered partitioning and full-inclusion assignment rules ensure that the number of triangles at each node remains within a controllable range, preventing comparison lag caused by storing too many triangles in a single node. This further improves the response speed of grid duplication identification, ensuring that duplicate grids can be quickly and accurately matched and referenced. This continuously strengthens the reduction effect of grid data redundancy, reduces the cost of hardware storage and computing resources, and lays a solid foundation for efficient rendering and subsequent applications of the fusion model.

[0064] Example 5: This embodiment is a further supplement and explanation based on embodiment 1. Specifically, in step D, if there is no index corresponding to the material light in the material array, the material light is appended to the end of the material array and the index is obtained; if there is no index corresponding to the texture in the texture array, the texture is appended to the end of the texture array and the index is obtained.

[0065] Specifically, in step D, when matching material lights, the material array is traversed to search for a completely matching material light. If no corresponding index is found, the material light is directly appended to the end of the material array. At this point, the position of the material light in the array becomes its unique index, which is directly obtained for subsequent material index assignment. Similarly, when matching textures, if there is no completely matching texture in the texture array, the texture is appended to the end of the texture array, and its position at the end of the array is used as its unique index. The entire process does not require shifting or reordering the existing data in the array; the index allocation of newly added data is achieved solely through appending to the end.

[0066] This embodiment ensures that each unique material light and texture is stored only once through appending to the end and using position indexing. This avoids duplicate storage problems caused by unclear index allocation rules from the source, further reducing data redundancy at the material and texture level. At the same time, the appending operation does not require complex array adjustment logic; it only needs to be written directly to the end, which greatly reduces the computational overhead of index allocation and accelerates the processing efficiency of material-related data. In addition, the dedicated index is directly bound to the array position, making the index lookup during subsequent material matching more intuitive and efficient, reducing the additional overhead of index mapping, indirectly improving the processing speed of the overall mesh fusion process, reducing hardware resource consumption, and ensuring the lightweight and efficient nature of the fusion model.

[0067] Example 6: This embodiment is a further supplement and explanation based on embodiment 1. Specifically, the data of each node in the node array is a quintuple (model name, model identifier, mesh index, material index, transformation matrix).

[0068] Specifically, the core information of each node is structurally integrated using a five-tuple format: the model name and model identifier are used as unique identification fields to ensure that each node corresponds to the original 3D model file, avoiding confusion between multiple models. The mesh index acts as a bridge between nodes and the mesh array, directly pointing to the storage location of the mesh data, enabling shared referencing of mesh data. The material index is associated with the material array, quickly locating the material information corresponding to the node without duplicate material data storage. The transformation matrix preserves the spatial position, rotation, and scaling characteristics of the original model, ensuring that the spatial pose of the fused model is consistent with the original. All nodes strictly adhere to this five-tuple format for storing information, achieving standardized input, storage, and retrieval of node information, ensuring that the function of each field is clear and the association logic is well-defined.

[0069] This embodiment uses a standardized five-tuple structure to eliminate the need for nodes to repeatedly store complete mesh and material data. Instead, nodes can access corresponding resources simply by associating them with an index, further reducing data redundancy at the node level and lowering the overall data volume in the fusion scenario. At the same time, the unified field format eliminates the need to parse complex heterogeneous information when associating nodes with meshes and materials. Target data can be quickly located directly through the index, reducing the lookup overhead for data association and accelerating the efficiency of data retrieval and integration in the fusion process.

[0070] Example 7: This embodiment provides a GIM 3D model fusion method. Based on a standardized data framework, this method introduces a spatial proximity triggering mechanism and a device semantic preservation strategy to achieve more efficient and complete model fusion. The specific steps are as follows: First, a fusion scenario is constructed as a unified container for data integration. This scenario includes a mesh array for storing all mesh geometry data, a material array for recording material optical properties, a texture array for storing texture images and parameters, a node array for managing model instance information, a quintuple mesh relationship table that establishes the association between mesh features and octrees, and an octree array for spatial retrieval and comparison. The quintuple mesh relationship table uses mesh quintuple features as keys, mapping to one or more octree indices to accelerate the retrieval process for duplicate meshes. In addition, a semantic mapping table is maintained independently within the scenario. This table uses the device's unique identifier as the key, linking to the corresponding mesh index, material index, and node index. This ensures that the links between the identity information, business attributes, and geometric representation of each power device are preserved during the fusion process, supporting subsequent interactive queries, attribute management, and business analysis. After completing the structure definition, all arrays and tables are initialized to empty or default values ​​to prepare for data injection.

[0071] The system iterates through all 3D model files in the GIM model. For each file, the system parses its internal structure, extracting the model identifier, model name, mesh data, material lighting, textures, transformation matrix, and unique device identifier (DeviceID, such as "TR-500kV-001", used to uniquely identify specific equipment in the substation). This extraction process eliminates redundant information such as file format parsing and irrelevant metadata, directly obtaining the core data items required for fusion, providing clean input for subsequent processing.

[0072] After extraction, a new node is created for each 3D model file. This node, representing the model instance in the merged scene, is assigned a model identifier, model name, transformation matrix, and DeviceID. The transformation matrix is ​​retained for correct placement of the model in the merged unified scene. The node's material and mesh indices are initially set to empty, as they need to be dynamically determined through subsequent matching and detection processes. This design makes the node structure lightweight and flexible, facilitating batch creation and updates.

[0073] The system compares the extracted material light with existing entries in the material array, using a component-wise precise matching (e.g., RGBA values). If a completely matching material light is found, its index number is directly obtained; otherwise, the material light is appended to the end of the material array, and its array index becomes the new index number. Texture processing follows the same logic, matching or appending by comparing the image pixel array with texture parameters. Then, the obtained material light index number and texture index number are combined to form the complete material index for that node. This mechanism ensures that identical materials and textures are stored only once in the merging scene and shared by multiple nodes through the index, significantly reducing data redundancy.

[0074] Upon entering the mesh processing stage, the geometric features of the current mesh are first calculated. The system statistically analyzes the mesh's span (sx, sy, sz) along the X, Y, and Z axes, the number of vertices it contains (np), and the number of triangle faces (nt). These five key parameters are combined into a quintuple (sx, sy, sz, np, nt) as the feature index of the mesh. This quintuple encapsulates the macroscopic geometry of the mesh, enabling rapid differentiation between meshes of vastly different sizes and complexities, providing a basis for initial screening. Next, spatial relationship judgment is performed: the minimum distance between the axis-aligned bounding box (AABB) of the current mesh and the bounding boxes of all existing meshes in the merged scene is calculated. If the minimum distance is less than a preset adjacency threshold (e.g., 0.1 meters, which can be configured based on the modeling accuracy of power equipment and typical installation spacing), the current mesh is determined to be spatially overlapping or adjacent to existing meshes in the scene. This judgment is crucial for triggering refined comparison; spatially isolated meshes can be directly added, avoiding unnecessary computational overhead.

[0075] When spatial proximity is detected, the system constructs or updates a global octree spatial index structure for all loaded mesh cells in the merged scene. The octree recursively divides the entire scene space into eight sub-cubes. Each mesh is assigned to the deepest node that completely contains it based on its bounding box; if a mesh spans multiple sub-regions, it is stored in the shallowest node that completely contains it. Each octree node maintains a list recording the mesh indices belonging to its spatial range. After constructing the octree, the system queries the pentad mesh relationship table using the current mesh's pentad feature as the key to retrieve all octrees associated with that feature.

[0076] Subsequently, a precise mesh redundancy determination is performed. For each associated octree, the system traverses downwards along the tree structure to locate the leaf node region where the current mesh's spatial position is located. Within this region, the system extracts a refined feature vector of the current mesh, i.e., a quintuple, including: vertex coordinate sequence, normal vector corresponding to each vertex, texture coordinates, a unique hash value generated based on material parameters, and device ID. This feature vector is then compared item by item with the corresponding feature vectors of all existing meshes within the target node. The comparison rules are: vertex coordinates must be completely identical within the allowed floating-point error (e.g., 1e-6); normal vector directions must be the same; texture coordinates must match; and material identifiers must be equal. Although device IDs are allowed to be different, in the redundancy determination logic, it is usually required that the device type or key attribute segments be consistent, or only geometry and material are compared at this stage, with semantic deduplication handled by subsequent modules. If all features are found to be completely matched, the current mesh is determined to be a redundant mesh.

[0077] If redundancy is detected, the system does not duplicate the vertex and triangle data of the current mesh in the mesh array; instead, it directly references the index number of an existing mesh. Simultaneously, in the semantic mapping table, a reference relationship is established between the DeviceID of the current mesh and the index of that existing mesh. This achieves single storage and multi-party referencing of geometric data. If redundancy is not detected, the current mesh is added as a new mesh to the end of the mesh array, a new index number is obtained, and a new octree is created for it. The new octree is added to the octree array, and the association between the current quintuple feature and the new octree is established in the quintuple mesh relationship table. Subsequently, all triangles of the new mesh are inserted into the new octree according to their spatial positions, completing its spatial index structure.

[0078] Next, the finalized mesh index is assigned to the mesh index field of the new node. At this point, the new node possesses a complete model identifier, name, transformation matrix, material index, mesh index, and DeviceID. This complete node is then added to the node array.

[0079] The system iteratively executes all the steps from file extraction to node addition until all 3D model files in the GIM model have been processed. Finally, the output is a fused 3D model consisting of a complete array of nodes, a deduplicated array of meshes, a material array, a texture array, and a semantic mapping table maintaining device-geometric relationships. This model not only greatly eliminates data redundancy at the material, texture, and mesh levels through index reuse, reducing storage and rendering load, but also significantly improves the efficiency of duplicate mesh detection through an octree spatial index and a quintuple feature comparison mechanism. More importantly, it fully preserves the unique identifier and semantic information of each original device, enabling the fused model not only for efficient visualization but also to directly support device-based click queries, attribute display, spatial analysis, and business integration. This provides a high-quality, lightweight, and information-complete 3D data foundation for digital operation and maintenance, simulation training, and intelligent decision-making in the power industry.

[0080] The method of this embodiment will be further illustrated below with a specific example. The specific solution is as follows: In the 3D digitization project of a 500kV smart substation expansion in a certain region, the original GIM data package handed over by the design institute contained a total of 385 independent 3D model files, covering equipment such as main transformers, circuit breakers, disconnect switches, current transformers, surge arresters, and structures. Preliminary analysis revealed 42 sets of identical "XXX-XXX type disconnect switches" installed on different busbar and line sides within the substation. In the original deliverables, these 42 sets of disconnect switches were stored as 42 independent model files, each containing identical mesh data, material lighting, and texture maps, differing only in spatial location and project identifiers.

[0081] Applying the method described in this embodiment, the system first constructs a fused scene and initializes the mesh array, material array, texture array, node array, quintuple mesh relationship table, octree array, and semantic mapping table. Then, it traverses all model files, extracting information such as model identifier, device unique identifier, mesh, material, texture, and transformation matrix from each file. When processing the first group of GW7 disconnect switches, the system calculates the quintuple feature index of its mesh and detects that the device has no spatially adjacent loaded meshes in the scene. Therefore, it adds the device as a new mesh to the mesh array, establishes the corresponding octree, and records the association between the device identifier and the mesh index in the semantic mapping table.

[0082] As the system processed the subsequent 41 groups of disconnect switches of the same model, the optimization mechanism gradually became apparent. In the material and texture matching stage, the system quickly identified materials and textures completely identical to those of the first group of devices through hash comparison, directly reusing existing index numbers. In the mesh processing stage, the system detected that these devices were close to the bounding boxes of the loaded meshes through spatial proximity detection, triggering local octree construction and refined comparison. Potentially duplicated meshes were quickly located using quintuple indexes, and after confirming geometric and material consistency through feature vector comparison, the system directly referenced existing mesh indexes and recorded the unique identifier of the current device under the corresponding mesh index in the semantic mapping table.

[0083] After all file processing is complete, the output fused scene still retains 385 independent records in the node array, ensuring the integrity of the identification, location, and attitude information for each device instance. Significant compression is achieved at the data storage level: the mesh data corresponding to 42 sets of disconnect switches of the same model is stored in only one copy, and materials and textures are also stored in only one copy each. The semantic mapping table fully records the reference relationship between each device identifier and the mesh and material used, enabling the system to accurately retrieve its engineering attributes and business information when clicking on any disconnect switch in the subsequent 3D platform.

[0084] Actual measurements show that the total data volume of the fused model in this case is reduced by approximately 22% compared to the original discrete files, with a particularly significant decrease in memory usage for meshes and textures. After deployment to the substation 3D visualization platform, scene loading time is reduced by approximately 35%, and the rendering frame rate is increased by approximately 18% in a typical view encompassing all substation equipment. The smoothness of the visuals is significantly improved, and interactive functions such as equipment selection and attribute viewing are fully retained, meeting the dual requirements of maintenance personnel for scene smoothness and information integrity.

[0085] Example 8: This embodiment provides a GIM 3D model fusion method. Based on a standardized fusion scene framework, this method deeply integrates high-precision coordinate normalization, hash-based structured feature comparison, dynamically triggered octree indexing, and rendering-oriented hierarchical scene organization, achieving end-to-end optimization from data source to final visualization output. The specific steps are as follows: The system constructs a hierarchical fusion scene as a unified container. This scene includes not only a mesh array for storing unique geometric data, a material array for recording optical properties, a texture array for storing image information, a node array for managing instances, a quintuple mesh relationship table, and an octree array, but also a hierarchical scene graph structure with clear engineering semantics. The top layer of the scene graph consists of substation or converter station container nodes, the middle layer is divided according to voltage level (e.g., 750kV zone, 500kV zone) or functional area, and the bottom layer consists of equipment instance nodes. Each equipment instance node is ultimately associated with its unique mesh index, material index, transformation matrix, and unique equipment identifier and business attributes extracted from the original GIM file. This structure is empty during initialization, laying a foundation with both spatial and semantic logic for subsequent data injection.

[0086] The system traverses all 3D model files and their associated metadata files within the GIM model. For each file, it extracts not only model identifiers, meshes, material lighting, and textures, but also specifically parses the precise installation location of the equipment and local coordinate system parameters from the metadata. Using these parameters, the system calculates a high-precision affine transformation matrix that transforms the model from the local coordinate system to the unified world coordinate system, including the rotation matrix R and the translation vector T. All vertex coordinates are transformed according to this matrix, fundamentally eliminating model misalignment or gaps caused by inconsistencies in the coordinate systems of the original design files.

[0087] After creating a new node for each file and assigning information such as model identifier and transformation matrix, material and texture matching is performed. This embodiment enhances this process by performing normalized hash calculations on the extracted material light and texture. For example, floating-point values ​​are quantized to a specific precision to generate a unique hash code. By comparing hash values ​​in the material and texture arrays instead of directly comparing the massive raw data, the system greatly improves the matching speed and effectively avoids misjudgments caused by minute differences in floating-point precision.

[0088] The system then enters the mesh processing phase. It calculates the spatial relationship between the current mesh's bounding box and all existing mesh bounding boxes in the merged scene. Only when overlapping bounding boxes are detected or the distance is less than a set threshold is the construction of an octree index for that local region triggered or updated. This is a dynamic, on-demand construction strategy, avoiding the overhead of pre-building a complete octree for sparse regions. For the mesh to be detected, the system calculates its axial span, number of vertices, and number of triangles to generate a quintuple (sx, sy, sz, np, nt) as a primary index.

[0089] The system queries the quintuple mesh relationship table using this quintuple as the key. If an associated octree exists, a refined comparison is performed. The comparison mechanism here is as follows: the system generates an enhanced feature fingerprint for the current mesh, which not only contains geometric information but also integrates mesh shared reference identifiers from the data source. After locating the corresponding spatial region in the octree, the comparison algorithm calculates the normalized hash value of the current mesh vertex coordinate sequence and the sorted hash value of the triangle index sequence, and performs a comprehensive comparison with the corresponding hash value, material hash, and shared reference identifier of existing records. This hash-based structured comparison, while ensuring geometric and material consistency, reduces the comparison complexity from geometric level to constant level and is resistant to floating-point error interference.

[0090] If a grid is determined to be redundant through comparison, an existing grid index is directly referenced, and the reference relationship from the current AssetID to this index is recorded in the semantic mapping table. If it is not redundant, the grid is added as new data to the grid array, and the corresponding octree node is dynamically updated or created. The octree node adopts an optimized design: internal nodes record the existence flag of child nodes, and leaf nodes are directly associated with the record set in the quintuple relation table. When the number of triangles in a leaf node exceeds a threshold, automatic splitting is performed to maintain spatial query efficiency.

[0091] Finally, the determined mesh index and material index are assigned to the new node, and this complete node is added to the corresponding device instance level of the node array. This process is repeated until all files are processed, resulting in a well-structured, deduplicated, coordinate-unified, and semantically preserved fused 3D scene. This scene can be efficiently utilized by a 3D rendering engine: the engine can logically organize the scene based on a layered scene graph; it uses an octree structure for fast frustum culling, submitting only visible data to the GPU; and because data redundancy has been eliminated, the memory usage of the vertex buffer and index buffer is significantly reduced, thereby greatly improving rendering frame rate and interactive smoothness.

[0092] The following will further illustrate the solution of this embodiment with a specific example, the details of which are as follows: In the 3D digital application of a cross-regional 500kV high-voltage transmission line upgrade and renovation project, the original GIM data provided by the design team came from three different design subcontractors, covering models of towers, conductors, insulators, and hardware for the expansion of two substations and the approximately 80-kilometer-long transmission line corridor between them. The data package contained more than 1,200 independent 3D files. Because each subcontractor used different local coordinate systems and modeling origins, and there were subtle differences in modeling details and texture processing, directly loading these models often resulted in problems such as model misalignment, component overlap, or gaps at the joints, making it difficult to accurately integrate and visualize the overall scene.

[0093] Applying the method described in this embodiment, the system first constructs a hierarchical fusion scene structure. The top layer represents the overall project nodes, while the lower layers are divided into "substation-line section-tower" hierarchical levels, laying the foundation for the semantic organization of subsequent data. When processing each 3D file, the system not only extracts model identifiers, meshes, materials, and textures, but also parses the local coordinate system parameters used in the file and its precise geographic reference location in the design from the accompanying metadata. By calculating a high-precision affine transformation matrix, the system uniformly transforms the coordinates of all vertices of each model to the global world coordinate system, fundamentally eliminating the model spatial misalignment problem caused by coordinate system inconsistencies, enabling accurate connection between substations and line towers in the fusion scene.

[0094] In the material and texture processing stage, to address the subtle floating-point differences in RGB values ​​among subcontractors for the same material (such as galvanized steel and ceramic insulation), the system performs normalized hash calculations on the extracted material and texture images. For example, color components are uniformly quantized to 8-bit precision to generate hash codes, and texture images are scaled to a fixed size before calculating perceptual hashes. By comparing hash values ​​rather than raw pixel data, the system quickly identifies and merges visually consistent materials and textures that differ only in numerical precision or file format, avoiding duplicate storage due to floating-point errors and significantly improving matching speed.

[0095] To address the sparse distribution of towers but significant duplication of insulators and hardware components within the transmission line corridor, the system employs a dynamic octree indexing strategy. When processing each grid, octree construction and updates for that local area are only triggered when its bounding box is detected to be spatially adjacent to or overlap with the bounding box of an existing model in the scene. For example, for hundreds of identical insulators on a single tower, the system builds a local octree when processing the first insulator. Subsequent insulators are quickly located using quintuple feature indexes, and further compared with the hash values ​​of their vertex coordinate sequences and triangle index sequences, which are then calculated and matched against existing hash values ​​in the octree nodes. This hash-based structured comparison ensures geometric consistency while minimizing comparison time.

[0096] Ultimately, the system outputs a well-structured, coordinate-unified, and deduplicated 3D scene. This scene not only fully preserves the unique identifiers and engineering attributes of each tower and device, but also clearly organizes the semantic relationships between substations, lines, and towers through a layered scene graph. After delivery to the line 3D operation and maintenance platform, scene loading time was reduced by approximately 40% due to the reduction in the number of files, elimination of data redundancy, and pre-unification of the coordinate system. During roaming, the rendering engine utilizes an octree structure for efficient frustum culling, submitting only tower and component data within the visible range to the GPU. Combined with a significant reduction in repetitive geometry and textures in video memory, the rendering frame rate maintained an improvement of approximately 25% in the panoramic view of long-distance line corridors, ensuring a smooth flight inspection experience. Simultaneously, maintenance personnel can still click on any device in the scene to accurately query its model, asset number, and maintenance records, achieving a balance between visualization performance and the integrity of business information.

[0097] Example 9: A GIM 3D model fusion system, used to implement the method described in any of the preceding aspects, comprising: The scene construction module is used to build and initialize the merged scene. The file extraction module is used to extract all 3D model files in the GIM model, and extract the model identifier, model name, mesh, material light, texture and transformation matrix of each 3D model file respectively; The node construction module is used to construct new nodes, assign model identifier, model name and transformation matrix to the new node, and initially set the material index and mesh index of the new node to empty; The material and texture processing module is used to obtain the material light index number by matching the material light in the material array, obtain the texture index number by matching the texture in the texture array, and assign a material index to the new node based on the material light index number and the texture index number. The grid index construction module is used to count the three-axis spans sx, sy, sz, the number of grid points np, and the number of triangles nt of the grid, and construct a quintuple (sx, sy, sz, np, nt) as the grid feature index. The grid processing module is used to query the quintuple grid relationship table using quintuples as keys. If the quintuple grid relation table contains at least one octree associated with the quintuple, then perform a triangle check on each associated octree: if all triangles in the grid exist in a certain octree, then reference the grid index corresponding to that octree. If no octree meets the conditions, add the grid as a new grid to the end of the grid array and obtain the grid index. Create a new octree and add it to the octree array. Establish the association between the quintuple and the new grid in the quintuple grid relationship table, and insert each triangle in the new grid into the newly created octree.

[0098] The node generation module is used to assign a grid index to a new node based on the grid index and add the new node to the node array; The output module is used to output the 3D model corresponding to the fused scene.

[0099] A GIM 3D model fusion device includes a memory and a processor. The memory stores a computer program, and the processor executes the program to implement the GIM 3D model fusion method as described in any of the preceding claims.

[0100] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A GIM 3D model fusion method, characterized in that, Includes the following steps: A. Construct the blended scene, which includes a mesh array, material array, texture array, node array, quintuple mesh relationship table, and octree array; initialize the blended scene; B. Extract all 3D model files from the GIM model, and extract the model identifier, model name, mesh, material lighting, texture, and transformation matrix of each 3D model file; C. Construct a new node, assign the model identifier, model name and transformation matrix to the new node, and initially set the material index and mesh index of the new node to empty; D, obtain the material light index number by matching the material light in the material array, obtain the texture index number by matching the texture in the texture array, and assign the material index to the new node based on the material light index number and the texture index number; E represents the three-axis spans sx, sy, sz, the number of grid points np, and the number of triangles nt of the statistical grid, and constructs a quintuple as the grid feature index; where the quintuple includes sx, sy, sz, np, and nt. F, query the quintuple grid relationship table using quintuples as keys: If the quintuple grid relation table contains at least one octree associated with the quintuple, then perform a triangle check on each associated octree: if all triangles in the grid exist in a certain octree, then reference the grid index corresponding to that octree. If no octree meets the conditions, add the grid as a new grid to the end of the grid array and get the grid index. Create a new octree and add it to the octree array. Establish the association between the quintuple and the new grid in the quintuple grid relationship table and insert each triangle in the new grid into the newly created octree. G assigns a grid index to a new node based on the grid index and adds the new node to the node array; H, repeat the BG step until all 3D model files have been processed, and output the 3D model corresponding to the fused scene.

2. The GIM 3D model fusion method according to claim 1, characterized in that: Material light is a quaternion, which includes diffuse light, ambient light, specular light, and self-emission. Diffuse light, ambient light, specular light, and self-emission are all quadruples r, g, b, a; r, g, b, and a are the red, green, blue, and transparency color components, respectively. The texture is a tuple consisting of a two-dimensional array of image pixels and texture coordinates wrapped around a marker; The material is a binary combination of material light and texture.

3. The GIM 3D model fusion method according to claim 1, characterized in that: The grid index is a quintuple of x-axis span, y-axis span, z-axis span, number of grid points, and number of grid triangles; the grid is defined as a binary tuple of a set of three-dimensional points and a set of triangles, where each triangle in the triangle set is formed by three indices in the point set.

4. The GIM 3D model fusion method according to claim 1, characterized in that, In step F, the specific steps for performing the triangle check on the octree are as follows: Starting from the root node of the octree, compare the triangles within the current node. If a matching triangle exists, the check is successful, and the process continues to the next triangle. If the current node fails the check, and the range of its child nodes is not smaller than the range of the triangle, then recursively check the child nodes. If the range of its child nodes is smaller than the range of the triangle, the check for the triangle is deemed to have failed.

5. The GIM 3D model fusion method according to claim 1, characterized in that, In step F, the specific steps for inserting the triangle into the newly created octree are as follows: Starting from the root node of the octree, triangles are inserted. If the number of triangles contained in the current node reaches the threshold, the current node is divided into subgrids. If a child node completely contains a triangle, the triangle is assigned to that child node; otherwise, it is retained in the current node. If the number of triangles contained in a child node reaches the threshold, the division and triangle assignment operations are recursively performed on that child node until all triangles are inserted.

6. The GIM 3D model fusion method according to claim 1, characterized in that, In step D, if there is no index corresponding to the material light in the material array, the material light is appended to the end of the material array and the index is obtained; if there is no index corresponding to the texture in the texture array, the texture is appended to the end of the texture array and the index is obtained.

7. The GIM 3D model fusion method according to claim 1, characterized in that, The data for each node in the node array consists of a quintuple of model name, model identifier, mesh index, material index, and transformation matrix.

8. A GIM 3D model fusion system, used to implement the method described in any one of claims 1-7, characterized in that, include: The scene construction module is used to build and initialize the merged scene. The file extraction module is used to extract all 3D model files in the GIM model, and extract the model identifier, model name, mesh, material light, texture and transformation matrix of each 3D model file respectively; The node construction module is used to construct new nodes, assign model identifier, model name and transformation matrix to the new node, and initially set the material index and mesh index of the new node to empty; The material and texture processing module is used to obtain the material light index number by matching the material light in the material array, obtain the texture index number by matching the texture in the texture array, and assign a material index to the new node based on the material light index number and the texture index number. The grid index construction module is used to count the three-axis spans sx, sy, sz, the number of grid points np, and the number of triangles nt of the grid, and construct a quintuple of sx, sy, sz, np, nt as the grid feature index. The grid processing module is used to query the quintuple grid relationship table using quintuples as keys. If the quintuple grid relation table contains at least one octree associated with the quintuple, then perform a triangle check on each associated octree: if all triangles in the grid exist in a certain octree, then reference the grid index corresponding to that octree. If no octree meets the conditions, add the grid as a new grid to the end of the grid array and get the grid index. Create a new octree and add it to the octree array. Establish the association between the quintuple and the new grid in the quintuple grid relationship table and insert each triangle in the new grid into the newly created octree. The node generation module is used to assign a grid index to a new node based on the grid index and add the new node to the node array; The output module is used to output the 3D model corresponding to the fused scene.

9. A GIM 3D model fusion device, characterized in that, It includes a memory and a processor, the memory storing a computer program, and the processor executing the program to implement the GIM 3D model fusion method as described in any one of claims 1 to 7.

Images