A method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons.
By adopting a layered rendering method based on a dynamic micro-polygon Gaussian splash model of the power grid, the problem of visual inconsistency in dynamic deformation and fault warning of power grid equipment is solved, and efficient rendering and stable monitoring of power grid equipment in complex environments are achieved.
Patent Information
- Application Number
- CN202610199551.8
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2026-02-11
- Publication Date
- 2026-11-10
- Estimated Expiration
- 2046-02-11
AI Technical Summary
In existing technologies, the dynamic deformation characteristics of power grid equipment and the real-time coordination of micro-polygon structures are insufficient, resulting in physical inconsistencies such as breakage and deformation distortion in conductor swing simulation. Furthermore, the visual presentation during fault warnings is disconnected from ambient lighting, affecting the smoothness and visual stability of real-time monitoring.
A layered rendering method based on a dynamic micropolygon Gaussian splash model of the power grid is adopted. By converting the Gaussian splash model into a dynamic micropolygon structure in real time, and combining the elastic deformation interpolation algorithm and the micropolygon dynamic topology update algorithm, the continuity and integrity of the conductors in complex environments are ensured. A lighting data streaming synchronization algorithm and micropolygon shader dynamic compilation technology are introduced to achieve seamless integration of fault areas and ambient lighting. A multi-view LOD prediction smoothing algorithm and micropolygon batch merging rendering technology are combined to optimize the rendering load fluctuation during the viewpoint switching process.
It significantly improves the visual realism of power grid equipment in dynamic environments and the intuitiveness of fault warnings, reduces rendering load fluctuations and screen jitter, and ensures the smoothness and visual stability of real-time monitoring.
Smart Images

Figure CN122244275B_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of power grid simulation technology, specifically to a method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons. Background Technology
[0002] Layered rendering acceleration of the Gaussian splash model for power grids is an effective technique for improving visual effects and is widely used in computer graphics and visual simulation. With the increasing demand for high-fidelity images, improving rendering efficiency to reduce computational resource consumption and time costs has become an important research direction. The Gaussian splash model for power grids essentially simulates the scattering process of light on the surface of objects at different layers through a Gaussian function, thereby generating natural and complex lighting effects. In this process, layered rendering technology allows the scene to be divided into multiple layers. By adopting different rendering strategies for different layers, the calculation process can be optimized, rendering speed can be improved, unnecessary computational overhead can be effectively reduced, the correspondence between the model and actual physical phenomena can be enhanced, and the quality of the rendering results can be guaranteed.
[0003] In existing technologies, under the influence of complex natural environments, the dynamic deformation characteristics of power grid equipment and the real-time coordination of micropolygon structures are insufficient, leading to physical inconsistencies such as breakage and deformation distortion in conductor swing simulations. When a power grid fault requires a high-brightness warning, the visual presentation of the fault area is disconnected from the surrounding ambient lighting due to the data synchronization delay between the dynamic micropolygon and the global illumination system, weakening the intuitiveness and integration of the status prompts. At the same time, during large-scale, multi-view inspections of the power grid, frequent viewpoint switching and dynamic adjustment of the micropolygon hierarchy cause severe fluctuations in rendering load and screen jitter, affecting the smoothness and visual stability of real-time monitoring. To address these issues, a layered rendering acceleration method based on a dynamic micropolygon-based Gaussian splash model for power grids is proposed. Summary of the Invention
[0004] To solve the above technical problems, the present invention is implemented through the following technical solution: a method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micro-polygons, comprising the following steps: Step 1: Extract the Gaussian splash model from the power grid scene, convert it into a dynamic micro-polygon structure in real time, and construct an elastic deformation parameter mapping table based on the power grid equipment type and deformation characteristics. Establish a real-time association between the micro-polygon vertices and the physical properties of the Gaussian sphere to achieve real-time, high-fidelity conversion of the Gaussian splash model in the power grid scene into a dynamic micro-polygon, ensuring that the physical properties and rendering data are synchronized in real time. Step 2: Integrate the elastic deformation interpolation algorithm and the micro-polygon dynamic topology update algorithm to adjust the deformation parameters of the Gaussian sphere and the vertex connection structure of the micro-polygon in real time. This ensures that the conductor swings continuously and remains structurally intact under complex weather conditions, significantly improving the continuity and physical consistency of the conductor swing simulation and effectively avoiding deformation distortion and visual breaks. Step 3 introduces a lighting data streaming synchronization algorithm and a micro-polygon shader dynamic compilation technology. When a power grid fault is triggered, the shader is recompiled in real time and the global lighting cache is synchronized. This achieves seamless integration of the high-brightness warning of the fault area with the surrounding ambient lighting, effectively eliminating visual disjointness and achieving seamless integration of fault warning with the natural lighting environment. This significantly enhances the intuitiveness and visual immersion of the status prompts. Step 4: For multi-view high-frequency data update scenarios, combine multi-view LOD prediction smoothing algorithm and micro-polygon batch merging rendering technology. Based on the view trajectory, predict the detail level switching node, merge adjacent micro-polygon drawing batches, reduce rendering load fluctuations caused by view switching, significantly reduce rendering load fluctuations and screen jitter during multi-view switching, and ensure the smoothness and stability of the inspection process. Step 5: Based on the camera's field of view and device status priority, the scene is divided into three layers: core, transition, and distant view. The number of micro-polygons in each layer is dynamically adjusted according to the real-time frame rate and video memory usage. Priority is given to ensuring the rendering quality of faulty areas and the center of the field of view. Under resource-constrained conditions, priority is given to ensuring the rendering quality of key areas, so as to achieve the optimal balance between visual quality and performance. Step 6: Continuously monitor the rendering pipeline load and image stability indicators. When frame rate jitter or memory overrun is detected, automatically trigger micropoly simplification and shader parameter degradation to ensure smooth rendering and visual consistency in large-scale multi-view inspections. This achieves adaptive load control and ensures long-term stability of rendering smoothness and visual consistency in complex scenes.
[0005] Preferably, step 1 specifically includes: Gaussian sphere data is extracted from the Gaussian splash model of the power grid. The position, radius and elasticity parameters are analyzed in real time based on the cross-engine intermediate data format to generate an initial dynamic micro-polygon mesh. This achieves cross-platform high-fidelity data conversion and ensures that the model rendering is highly consistent with the actual physical structure. Based on the type of power grid equipment, an elastic deformation parameter mapping table is constructed. The high-density Gaussian sphere of rigid equipment is mapped to a high-stiffness micro polygon, and the slender Gaussian sphere of flexible equipment is mapped to a deformable micro polygon, thereby improving the deformation simulation accuracy and visual realism of different equipment in dynamic environments. A real-time correlation mechanism between the physical properties of micropolygon vertices and Gaussian spheres is established. Deformation coefficients, density, and elastic modulus are passed through the vertex shader to support real-time physical synchronization in dynamic environments, ensuring real-time synchronization between physical simulation and visual rendering, and avoiding deformation delay and visual breaks.
[0006] Preferably, step 2 specifically includes: By integrating the elastic deformation interpolation algorithm, Gaussian spherical variables are calculated in real time based on wind speed and icing weight parameters, and smooth deformation curves are generated through interpolation. This allows the conductor to exhibit a continuous and natural oscillation that conforms to physical laws under external forces, avoiding abrupt distortion. Based on the micropolygon dynamic topology update algorithm, the vertex connection structure of the micropolygon is reorganized according to the position of the Gaussian sphere after deformation, maintaining the continuity of the wire mesh and ensuring that the mesh remains intact and closed during dynamic deformation. This eliminates vertex penetration and breakage phenomena. The physical state and connection relationship of the micropolygon vertices are updated every frame, ensuring that there is no breakage or vertex penetration during the swing of the wire under complex weather conditions. This achieves real-time synchronization and stable rendering of wire deformation in complex weather environments, improving visual realism and structural consistency.
[0007] Preferably, step 2 further includes: During the oscillation of the wire, the distance between adjacent Gaussian spheres is detected in real time. If it exceeds the preset threshold, dynamic subdivision or merging of micro polygons is triggered, and the grid density is dynamically adjusted to ensure that the wire remains smooth and continuous during the oscillation and avoid visual breaks. The quaternion interpolation algorithm is used to smooth the rotational deformation of micropolygons, maintain the visual continuity of the wire bends, eliminate surface flicker caused by discrete frame updates, and improve the visual realism of the bends. A physical constraint solver is introduced to apply stretching and bending constraints to the vertices of the micropolygons to prevent non-physical folding or twisting during the deformation process, ensure that the wire swing conforms to the mechanical properties of the material, and avoid non-physical deformation.
[0008] Preferably, step 3 specifically includes: An illumination data streaming synchronization algorithm is introduced to obtain ambient light, shadow, and reflection data from the global illumination system in real time when a fault is triggered, so as to realize real-time synchronization between the fault area and the surrounding illumination environment and eliminate the visual discontinuity caused by illumination delay. By using micropolygon shader dynamic compilation technology, custom shader code with highlighted outlines and blinking effects is generated according to the fault type, supporting fault type adaptive visual warnings and enhancing the intuitiveness and dynamic expressiveness of status prompts; The compiled shader is injected into the rendering pipeline in sync with the global illumination cache, so that the faulty area is seamlessly integrated with the ambient lighting, ensuring that the faulty highlight effect blends naturally with the scene lighting, improving visual consistency and environmental immersion.
[0009] Preferably, step 3 further includes: During the dynamic compilation of the shader, color gradient functions and transparency blending parameters are injected in real time to complete the smooth transition of the fault area from the normal state to the highlighted state. The fault area presents a smooth color and transparency gradient, which is visually natural and avoids visual discomfort caused by abrupt changes in the warning. By combining optical buffer pre-computation with real-time probe fusion, the high light reflection of the fault area and the ambient shadow are interpolated and synthesized at multiple levels. It also supports the dynamic adjustment of the light response curve of the fault area, ensuring that the warning effect is consistent with the environment under different times and weather conditions. The warning effect is naturally integrated with the surrounding light, avoiding visual discontinuity and improving the realism of the environment and the recognizability of the warning.
[0010] Preferably, step 4 specifically includes: Based on the multi-view LOD prediction smoothing algorithm, the detail level nodes that may switch in the next 3-5 frames are pre-calculated according to the camera movement trajectory, which significantly reduces the visual jump caused by the viewpoint switch and improves the smoothness of the picture. By using micropolygon batch merging rendering technology, micropolygons of the same level within adjacent view frustums are merged into a single rendering batch, effectively reducing the number of rendering calls, improving rendering efficiency and frame rate stability. The batch merging strategy is dynamically adjusted during viewpoint switching to reduce rendering call fluctuations caused by LOD jumps, avoid screen jitter, and ensure visual continuity during multi-view inspection.
[0011] Preferably, step 4 further includes: Establish a view-level association cache table to record the optimal micro-polygon combination and batch configuration under each view, effectively utilize the computation cache, and significantly reduce the real-time computation overhead under the same or similar view. During continuous perspective switching, a dual-buffering mechanism is used to progressively update micropolygon batches to avoid screen stuttering. Asynchronous data preparation and smooth switching ensure highly smooth rendering of the screen when the perspective changes. It supports efficient submission of batch micropolygons through the Niagara system in UE and through GPU instantiation in Unity. It fully utilizes the core features of different engines to achieve efficient batch rendering across platforms and improve overall throughput.
[0012] Preferably, step 5 specifically includes: Based on the camera's field of view center angle and the equipment's fault status, the scene is divided into three layers: core, transition, and background, and each layer is assigned a rendering priority that decreases progressively, effectively focusing on key areas and improving visual attention concentration. Each frame dynamically adjusts the number of micro-polygons in each layer based on the real-time frame rate and video memory usage, prioritizing the complete rendering of the core layer and faulty areas, and ensuring that critical areas always maintain high-fidelity rendering quality when resources are scarce. When the frame rate is lower than the preset frame rate threshold, the number of micro-polygons in the distant layer is automatically reduced, and visual continuity is maintained through interpolation algorithms, which significantly alleviates performance pressure and avoids screen stuttering and visual breaks.
[0013] Preferably, step 6 specifically includes: Real-time monitoring of rendering pipeline load metrics, including frame rate variance, video memory usage, and number of draw calls, allows for quick identification of performance bottlenecks, ensuring real-time system response and improving monitoring accuracy. When frame rate jitter or video memory overload is detected, the micro-polygon simplification mechanism is automatically triggered to reduce the mesh complexity of non-critical areas, effectively alleviate resource pressure, maintain the rendering quality of critical areas, and avoid screen stuttering. Simultaneously perform shader parameter degradation, turn off high-overhead lighting effects, and fall back to the pre-computed lighting model to ensure stable and visually consistent visuals during inspections, smooth transitions in visual performance, maintain visual continuity, and improve comfort during long-term inspections.
[0014] This invention provides a method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micro-polygons. It offers the following advantages: (I) The method for accelerating the layered rendering of the Gaussian splash model of the power grid based on dynamic micropolygons, by integrating the elastic deformation interpolation algorithm and the dynamic topology update mechanism of micropolygons, can dynamically adjust the deformation state and connection structure of the Gaussian sphere and its corresponding micropolygons according to real-time environmental parameters. It maintains the continuity and physical rationality of the mesh in complex dynamic behaviors such as conductor swing, effectively avoids the deformation breakage and distortion phenomena common in traditional methods, and significantly improves the realism of dynamic simulation of power grid equipment under the influence of natural environment.
[0015] (ii) The method for accelerating the layered rendering of the Gaussian splash model of the power grid based on dynamic micro polygons, with the help of the lighting data streaming synchronization algorithm and the dynamic compilation technology of shaders, can obtain global lighting information in real time at the moment of fault triggering and generate warning effects such as highlighting and flashing. Through color gradient, transparency mixing and multi-level lighting fusion mechanism, the fault area is visually seamlessly connected with the ambient lighting, which greatly enhances the intuitiveness of the status prompt and the sense of environmental integration, and eliminates visual disjointness.
[0016] (III) The method for accelerating layered rendering of the Gaussian splash model of the power grid based on dynamic micropolygons combines a multi-view LOD prediction smoothing algorithm with micropolygon batch merging rendering technology. It can predict the layer switching nodes based on the camera trajectory and dynamically merge the rendering batches, effectively reducing the rendering load fluctuation and screen jitter caused by rapid changes in viewpoint, and ensuring the smoothness of visual output and frame rate stability during large-scale, multi-view inspection. Attached Figure Description
[0017] Figure 1 This is a schematic diagram illustrating the workflow of a layered rendering acceleration method for a Gaussian splash model of a power grid based on dynamic micropolygons, as described in this invention. Figure 2 This is a schematic diagram of the method flow for accelerating the layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons, according to the present invention. Detailed Implementation
[0018] 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 skilled in the art without creative effort are within the scope of protection of the present invention.
[0019] Example 1, please refer to Figure 1 , Figure 2 This invention provides a technical solution: a method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micro-polygons, comprising the following steps: Step 1: Extract the Gaussian splash model from the power grid scene and convert it into a dynamic micro-polygon structure in real time. Construct an elastic deformation parameter mapping table based on the power grid equipment type and deformation characteristics. Establish a real-time association between the micro-polygon vertices and the physical properties of the Gaussian sphere. This achieves real-time, high-fidelity conversion of the Gaussian splash model from the power grid scene to the dynamic micro-polygon, ensuring real-time synchronization of physical properties and rendering data. Extract Gaussian sphere data from the power grid Gaussian splash model and parse the position, radius, and elastic parameters in real time based on a cross-engine intermediate data format to generate an initial dynamic micro-polygon mesh, achieving high-fidelity data conversion across platforms. To ensure that the model rendering is highly consistent with the actual physical structure, an elastic deformation parameter mapping table is constructed based on the type of power grid equipment. The high-density Gaussian sphere of rigid equipment is mapped to a high-stiffness micropolygon, and the slender Gaussian sphere of flexible equipment is mapped to a deformable micropolygon. This improves the deformation simulation accuracy and visual realism of different equipment in dynamic environments. A real-time correlation mechanism between the vertices of the micropolygon and the physical properties of the Gaussian sphere is established. The deformation coefficient, density, and elastic modulus are passed through the vertex shader to support real-time physical synchronization in dynamic environments. This ensures real-time synchronization between physical simulation and visual rendering and avoids deformation delay and visual breaks. Furthermore, in the specific implementation, Gaussian sphere sequences are extracted from the intermediate data file of the power grid Gaussian splash model. This intermediate data format uses binary encoding, and each record contains location coordinates, radius, elasticity coefficient, and equipment type identifier. These fields are parsed in real time through a cross-engine adaptation layer (using the C++ FGaussianDataLoader class on the UE side and the C# GaussianDataLoader script on the Unity side) to generate an initial dynamic micro-polygon mesh corresponding one-to-one with the Gaussian spheres. Each micro-polygon consists of 12-24 vertices, determined according to the position of the Gaussian sphere. Vertex positions are generated using a cube subdivision algorithm based on the radius, while initial elastic parameters are bound. This process is executed asynchronously outside the rendering thread, with a maximum of 5000 Gaussian spheres parsed per frame and a parsing latency of no more than 5 milliseconds, ensuring real-time performance meets the requirements of interactive scenarios. Based on the type of power grid equipment (rigid equipment such as transmission towers, flexible equipment such as conductors), an elastic deformation parameter mapping table is constructed. For rigid equipment, the Gaussian sphere density is ≥80 spheres / cubic meter, the stiffness coefficient of the mapped micro-polygon is set to 1.0, and the upper limit of deformation is 2% of the radius. For flexible equipment, slender Gaussian spheres with an aspect ratio of 10:1 are used, and the mapping... The micropolygon has a stiffness coefficient of 0.2-0.5, allowing deformation up to 30% of its radius. The micropolygon vertices receive and transmit deformation coefficients, density, and elastic modulus in real time via the vertex shader's attribute stream. The elastic modulus for rigid devices is set to 200 GPa, while for flexible devices it is 10-50 GPa. The vertex shader updates the physical attribute buffer every frame, and the ComputeShader synchronizes attributes with mesh vertices on the GPU, ensuring consistent updates between physical simulation and rendering data in dynamic environments. Material is embedded in the rendering pipeline. The physical state synchronization module enables real-time association between the vertices of the micropolygon and the physical properties of the Gaussian sphere. During the pre-rendering callback phase of each frame, this module calculates the actual deformation of the Gaussian sphere based on environmental parameters such as wind speed and icing load using a predefined elastic deformation curve, and drives the micropolygon vertex position update. The vertex shader receives the deformation offset and rotation quaternion, and smoothly transitions the vertex state through linear interpolation to avoid abrupt changes. During the synchronization process, a double buffering mechanism is used to manage vertex attribute data to ensure data consistency between the physics thread and the rendering thread, with latency controlled within 8.3 milliseconds (corresponding to a 120Hz update frequency). Step 2: Integrating the elastic deformation interpolation algorithm and the micropolygon dynamic topology update algorithm, the deformation parameters of the Gaussian sphere and the vertex connection structure of the micropolygon are adjusted in real time to ensure that the conductor swings continuously and structurally intact under complex weather conditions. This significantly improves the continuity and physical consistency of the conductor swing simulation, effectively avoiding deformation distortion and visual breaks. The elastic deformation interpolation algorithm calculates the Gaussian sphere deformation variable in real time based on wind speed and icing weight parameters, and interpolates to generate a smooth deformation curve, so that the conductor exhibits a continuous and physically consistent natural swing under external force, avoiding abrupt distortion. Based on the micropolygon dynamic topology update algorithm, the vertex connection structure of the micropolygon is reorganized according to the position of the Gaussian sphere after deformation, maintaining the continuity of the conductor mesh and ensuring that the mesh remains intact and closed during dynamic deformation, eliminating vertex penetration and breakage. The physical state and connection relationship of the micropolygon vertices are updated every frame to ensure that there are no breaks or vertex penetrations during the conductor swing under complex weather conditions, achieving real-time synchronization and stable rendering of conductor deformation in complex weather environments, and improving visual realism and structural consistency. Furthermore, during the physics update phase before each frame's rendering, the deformation of the Gaussian sphere is calculated in real-time based on the current environmental parameters. Wind speed parameters are input in meters per second, and icing weight is loaded in kilograms per meter. After preprocessing by the physics engine, the elastic coefficient (1.0 for rigid devices, 0.2-0.5 for flexible devices) and elastic modulus (200 GPa for rigid devices, 10-50 GPa for flexible devices) of the Gaussian sphere are combined. Hooke's law and aerodynamic damping models are used to calculate the deformation displacement of each Gaussian sphere in the current frame. The deformation calculation is based on the sphere's center and decomposes into three axial components along the direction of wind and gravity. The deformation in each direction is limited to the upper limit of its radius (no more than half for rigid devices). The deformation curve is generated using cubic Hermit interpolation algorithm, based on the deformation history data of the most recent 5 frames, to eliminate deformation jumps between frames. The interpolation step size is fixed at 0.0167 seconds (corresponding to a physical update frequency of 60Hz) to ensure that the deformation process is visually continuous and conforms to physical laws. The position of the Gaussian sphere after deformation drives the dynamic reconstruction of the vertex connection structure of the micro-polygon. Based on the updated position of the Gaussian sphere, the topological connection between the micro-polygons corresponding to adjacent Gaussian spheres is reconstructed in real time using the Delaunay triangulation algorithm. During the reconstruction process, the Euclidean distance between each pair of adjacent micro-polygon vertices is detected. If the distance exceeds the preset continuity threshold (set as the sum of the radii of the two Gaussian spheres), the connection is considered complete. If the value is 1.2 times that of the original value, a transition vertex is inserted into the gap, and the mesh is retriangulated to maintain its continuity and closure. Simultaneously, the physical state attributes of the micropolygon vertices are updated each frame, including position, normals, and deformation weights. Quaternion rotation interpolation in the vertex shader is used to smooth vertex pose changes, preventing visual breaks caused by drastic deformation. The topology update module runs on an independent physics thread, processing a maximum of 10,000 micropolygons per frame to ensure the wire mesh remains intact and free of vertex penetration even under complex weather conditions. Before each frame's rendering callback begins, the vertex data of the micropolygons is synchronized using a double-buffering mechanism. The vertex positions, normals, and deformation parameters calculated by the physics thread are first written to the back buffer. The rendering thread reads data from the front buffer for drawing. The double buffer swapping timing is controlled after the vertical synchronization signal, and the swapping delay does not exceed 1 millisecond. The deformation offset and rotation quaternion received by the vertex shader are linearly interpolated and combined with the pre-compiled physical material parameters to update the GPU vertex buffer in real time. To ensure data consistency under high-frequency updates, lightweight verification is performed on the vertex attribute data updated in each frame. The verification includes the validity of the data range (position offset does not exceed the deformation limit) and the integrity of the topological connection (the distance between adjacent vertices is within the threshold). The entire synchronization process is completed within 8.3 milliseconds (120Hz update cycle), ensuring a high degree of consistency between physical simulation and visual presentation in complex dynamic environments. In addition, step 2 also includes: during the oscillation of the conductor, the distance between adjacent Gaussian spheres is detected in real time. If it exceeds the preset threshold, dynamic subdivision or merging of micro-polygons is triggered, and the mesh density is dynamically adjusted to ensure that the conductor remains smooth and continuous during the oscillation, avoiding visual breaks. Quaternion interpolation algorithm is used to smooth the rotation deformation of micro-polygons, maintain the visual coherence of the conductor's bend, eliminate surface flicker caused by discrete frame updates, improve the visual realism of the bend, and introduce a physical constraint solver to apply stretching and bending constraints to the vertices of the micro-polygons to prevent non-physical folding or twisting during the deformation process, ensuring that the oscillation of the conductor conforms to the mechanical properties of the material and avoiding non-physical deformation. Furthermore, during the oscillation of the conductor, the Euclidean distance between adjacent Gaussian spheres is detected in real time. This distance threshold is set to 1.2 times the sum of the radii of the two Gaussian spheres. This coefficient is experimentally determined based on the elastic limit of the conductor material and the requirements of visual continuity, ensuring a balance between physical realism and rendering quality. When the distance between adjacent Gaussian spheres exceeds this threshold, a dynamic subdivision mechanism for micropolygons is triggered: the center position of the gap is calculated, and this point is used as the insertion point of the new Gaussian sphere. The radius is taken as the arithmetic mean of the radii of the two adjacent spheres. The elastic coefficient and elastic modulus are determined by linear interpolation based on the device type of the Gaussian spheres on both sides. The newly inserted Gaussian sphere generates a set of transition micropolygons, which are then integrated with the original mesh using the Delaunay triangulation algorithm. Seamless integration is achieved, with a maximum of no more than 50 new Gaussian spheres added per frame during subdivision to avoid excessive topology reconstruction load. Conversely, when the distance between adjacent Gaussian spheres is less than 60% of a threshold, the micropolygons in that region are merged. A vertex fusion algorithm merges the corresponding meshes of two spheres into a simplified micropolygon, with the number of vertices after merging controlled within 70% of the original total to maintain an optimized balance between geometric detail and performance. A quaternion interpolation algorithm is used to smooth the rotation state of the micropolygons during deformation, maintaining visual continuity at bends in the wires. Each micropolygon vertex is associated with a quaternion rotation parameter, which is calculated jointly from the Gaussian sphere deformation displacement and normal change, with an update frequency of [missing information]. Once per physical frame, in the vertex shader, the rotation quaternion of the current frame and the rotation quaternion of the previous frame are smoothly transitioned through spherical linear interpolation. The interpolation weight is dynamically adjusted according to the deformation rate, with an adjustment coefficient ranging from 0.1 to 0.9. This ensures that the surface normal of the micropolygon at the bending part of the wire changes continuously during the oscillation process, eliminating surface flickering or breakage caused by discrete frame updates, and controlling the visual coherence error within 0.1 radians per pixel. A physical constraint solver based on position dynamics is introduced to prevent non-physical folding or twisting during deformation. This physical constraint solver applies two types of constraints to the micropolygon vertices: stretching constraints limit the change in distance between adjacent vertices to no more than 1 radian. The bending constraint limits the change in the angle between the normals of adjacent triangular facets to no more than 30 degrees, with a distance of 15% from the original distance. The constraint solution iterates 5 times per physical frame. In each iteration, the vertex position adjustment is calculated and updated to the physical buffer. The solution process uses the Gauss-Seidel relaxation algorithm with a relaxation factor of 0.8 to ensure convergence speed and stability. The constraint violation detection threshold is 2% of the stretching distance or 1.5% of the bending angle. When a violation is detected, it is corrected in real time within the frame. The corrected vertex position is synchronized to the rendering pipeline through a double buffer mechanism. This constraint solver works in conjunction with the deformation calculation module to ensure the physical rationality and visual integrity of the mesh structure during the wire swing. Step 3 introduces a lighting data streaming synchronization algorithm and micro-polygon shader dynamic compilation technology. When a power grid fault is triggered, the shader is recompiled in real time and the global illumination cache is synchronized, achieving seamless integration of the fault area's highlighted warning with the surrounding ambient lighting. This effectively eliminates visual disjointness and significantly enhances the intuitiveness and visual immersion of the status prompts. The lighting data streaming synchronization algorithm obtains ambient light, shadow, and reflection data from the global illumination system in real time when a fault is triggered, achieving real-time synchronization between the fault area and the surrounding lighting environment, eliminating the visual disjointness caused by lighting delay. Through micro-polygon shader dynamic compilation technology, custom shader code containing highlighted outlines and flashing effects is generated according to the fault type, supporting adaptive visual warnings for fault types, enhancing the intuitiveness and dynamic expressiveness of the status prompts. The compiled shader and global illumination cache are synchronously injected into the rendering pipeline, allowing the fault area to seamlessly integrate with the ambient lighting effects, ensuring that the fault highlight effect blends naturally with the scene lighting, improving visual consistency and environmental immersion. Furthermore, at the moment of fault triggering, ambient light intensity, dynamic shadow maps, and screen space reflection data are acquired in real time from the global illumination system via a lighting data streaming synchronization algorithm. Ambient light intensity is transmitted in floating-point array format, corresponding to HDR illumination intensity of 0-100,000 lumens; the shadow map resolution is 2048×2048, using a 32-bit depth format, and its update frequency is synchronized with the rendering frame rate; screen space reflection data is generated in real time based on the normal and roughness channels in the GBuffer, with a reflection sampling radius set to 12 pixels. All lighting data is transmitted through a shared video memory buffer with a latency of no more than 2 milliseconds. Simultaneously, the spatial coordinates and influence radius of the faulty device are monitored. When the fault status flag changes from 0 to 1, illumination data capture is immediately triggered. The capture range is a spherical area with a radius of 50 meters centered on the fault point, ensuring that the collected ambient illumination information matches the fault area space. Based on the acquired fault type code (overload, short circuit, insulation failure), the micro-polygon shader dynamic compilation module calls the pre-set HLSL / GLSL template library to generate custom shader code containing highlight contours and periodic flashing effects. The screen space distance field algorithm is used to determine the highlight contours, and the contour width is set to 3 to 8 pixels according to the fault level. The color mapping is from RGB(255, 80, 80) to RGB(255, 200). The linear gradient is 80%. The flickering effect is achieved through a time modulation function, with the frequency set from 1Hz to 4Hz depending on the urgency of the fault, and the duty cycle adjusted from 30% to 70%. Shader compilation is performed in a separate compilation thread, using a real-time shader compilation pipeline, with an average compilation time of 15 milliseconds. After compilation, the generated shader bytecode is immediately registered to the renderer's shader resource library and assigned a unique resource identifier. The compiled shader is injected into the rendering pipeline of the current frame through the rendering command queue, replacing the original material shader in the pixel shader stage. At the same time, the ambient light, shadow, and reflection data in the global illumination buffer are synchronized with the constant buffer through the texture array. Step-by-step binding to the new shader: Ambient light cubemap, shadow map, and screen space reflection data are bound to the corresponding texture units; Light intensity, direction, and color correction parameters are updated once per frame through a constant buffer. A cache consistency check is performed before the shader is executed to ensure that the timestamp of the lighting data matches the current frame number. The highlight and flickering effects of the fault area are calculated in real time based on the fused lighting data. Its color output is synthesized with the surrounding ambient light using α mixing (mixing factor 0.6 to 0.8) to achieve seamless visual fusion. The color difference rate of the final output pixels is controlled within 5%, ensuring that the fault warning effect is prominent and naturally connected with the ambient light. In addition, step 3 also includes: during the dynamic compilation of the shader, injecting color gradient functions and transparency mixing parameters in real time to complete the smooth transition of the fault area from normal to highlighted state. The fault area presents a smooth color and transparency gradient, with a natural visual transition, avoiding visual discomfort caused by abrupt warning changes. Through light cache pre-computation and real-time probe fusion, the highlight reflection of the fault area and the ambient shadow are interpolated and synthesized at multiple levels. It also supports the dynamic lighting response curve adjustment of the fault area to ensure that the warning effect is consistent with the environment under different times and weather conditions. The warning effect is naturally integrated with the surrounding lighting to avoid visual discontinuity and improve the realism of the environment and the recognizability of the warning. Furthermore, during the dynamic compilation phase of the shader, color gradient functions and transparency blending parameters are injected in real time to achieve a smooth transition from the normal state to the highlighted state in the fault area. The color gradient function uses cubic Bézier curve interpolation, with the time factor as the input parameter. The output color value linearly transitions from the base color to the target warning color in the RGB space. The transparency blending parameter is dynamically adjusted according to the fault level. The initial transparency is set to 1.0 (completely opaque), and during the transition period, it is gradually reduced to the range of 0.6 to 0.8 according to an exponential decay function. The decay time constant is set to 0.5 seconds to ensure that the visual change is natural and conforms to the inertia of human visual perception. All parameters are updated every frame through the shader constant buffer, and the update frequency is related to the rendering frame rate. Synchronous interpolation calculations for color and transparency are performed within the pixel shader, using hardware-supported linear interpolation instructions to ensure smooth, seamless transitions for each pixel. Through a combination of light cache pre-computation and real-time probe fusion technology, the specular reflections and ambient shadows of the fault area are interpolated and synthesized at multiple levels. During the light cache pre-computation stage, a cube map containing diffuse, specular, and ambient occlusion information is pre-generated based on the scene's static lightmap and dynamic light probe data, with a resolution of 512×512 and an RGBA16F format. Upon fault triggering, the real-time probe deploys 4 to 8 sampling points within a 10-meter radius of the fault point to collect ambient lighting data for the current frame. The pre-computation buffer... The stored and real-time probe data are fused using a weighted mixing algorithm. The weights are dynamically calculated based on the probe sampling confidence and distance attenuation factor. The mixed lighting data is passed to the shader via a texture array. The specular reflectance coefficient is adjusted between 0.1 and 0.9 according to the surface material roughness. Ambient shadows are softened by combining screen space shadow mapping with pre-computed shadow maps and using percentage progressive filtering with a 3×3 filter kernel size. To support dynamic lighting response of the fault area under different time and weather conditions, an adjustable lighting response curve mechanism is introduced. This curve uses ambient light intensity (in lumens) as the horizontal axis and the brightness gain and hue shift of the warning effect as the vertical axis, calculated using a piecewise linear function or a quadratic function. The curve describes its mapping relationship. Under low-light conditions at night (ambient light intensity < 100 lumens), the warning brightness gain is increased by 1.5 times, and the hue shifts towards warmer colors (color temperature increases by 500K). Under high-light conditions during the day (ambient light intensity > 10000 lumens), the gain is maintained at 1.0 to 1.2 times, and the color temperature remains neutral. The response curve parameters are stored in a scriptable configuration file and support runtime hot updates. The shader obtains adjustment parameters in real time by querying the lighting response curve texture (1D texture, 256 pixels wide) and performs final synthesis with the color gradient, transparency blending, and lighting fusion results to ensure that the warning effect maintains visual consistency and environmental integration under different lighting conditions. Step 4: For multi-view high-frequency data update scenarios, combine multi-view LOD prediction smoothing algorithm and micro-polygon batch merging rendering technology. Based on the view trajectory, predict the detail level switching node, merge adjacent micro-polygon drawing batches, reduce rendering load fluctuations caused by view switching, significantly reduce rendering load fluctuations and screen jitter during multi-view switching, and ensure the smoothness and stability of the inspection process. Step 5: Based on the camera's field of view and device status priority, the scene is divided into three layers: core, transition, and distant view. The number of micro-polygons in each layer is dynamically adjusted according to the real-time frame rate and video memory usage. Priority is given to ensuring the rendering quality of faulty areas and the center of the field of view. Under resource-constrained conditions, priority is given to ensuring the rendering quality of key areas, so as to achieve the optimal balance between visual quality and performance. Step 6: Continuously monitor the rendering pipeline load and image stability indicators. When frame rate jitter or memory overrun is detected, automatically trigger micropoly simplification and shader parameter degradation to ensure smooth rendering and visual consistency in large-scale multi-view inspections. This achieves adaptive load control and ensures long-term stability of rendering smoothness and visual consistency in complex scenes.
[0020] Example 2, as Figure 1 , Figure 2 As shown, based on Embodiment 1, the present invention provides a technical solution: Step 4 specifically includes: based on the multi-view LOD prediction smoothing algorithm, the detail level nodes that may switch within the next 3-5 frames are pre-calculated according to the camera movement trajectory, which significantly reduces the visual jump caused by the viewpoint switch and improves the smoothness of the picture. Through the micro-polygon batch merging rendering technology, the micro-polygons of the same level in adjacent view frustums are merged into a single rendering batch, which effectively reduces the number of rendering calls, improves rendering efficiency and frame rate stability, and dynamically adjusts the batch merging strategy during the viewpoint switch to reduce the rendering call fluctuation caused by LOD jump, avoid picture jitter, and ensure the visual continuity during multi-view inspection. Furthermore, in its implementation, the multi-view LOD prediction smoothing algorithm takes the camera's movement trajectory as input. By analyzing its current frame position, velocity, and acceleration data, it pre-calculates the possible spatial distribution of the camera's view frustum within the next 3 to 5 frames. Each frame records the camera's position vector and pose quaternion in the world coordinate system. Based on a second-order motion model, it infers the viewpoint changes in subsequent frames. According to the spatial relationship between the pre-calculated view frustum and the set of micro-polygons in the scene, it dynamically determines the level of detail for each micro-polygon in future frames. There are four levels of detail (LOD0 to LOD3), corresponding to simplified meshes with vertex densities of 100%, 60%, 30%, and 10%, respectively. During the prediction process, a hybrid criterion based on viewing distance and screen projection area is used: when the center of the micro-polygon... When the distance to the predicted viewpoint exceeds a threshold (50 meters for LOD1, 150 meters for LOD2, and 300 meters for LOD3) or its projected pixel area is less than a set threshold (256, 64, and 16 pixels respectively), it is determined that a lower level should be switched. The prediction result is temporarily stored in the memory buffer as a level identifier array and updated every frame. After obtaining the prediction level data, the micropolygon batch merging rendering technology clusters and merges micropolygons belonging to the same detail level. Based on the principle of spatial continuity, adjacent micropolygons at the same level are grouped, with each group containing a maximum of 512 micropolygons. During merging, the vertex data of multiple micropolygons are integrated into the same drawing batch through vertex buffer reorganization. Each batch corresponds to a DrawCa. During batch generation, index buffer reuse and vertex attribute interleaving storage are used to optimize data layout and reduce GPU memory bandwidth usage. During viewpoint switching, the merging strategy is dynamically adjusted: when the camera angular velocity exceeds 30 degrees / second, the spatial continuity requirement for merging similar groups is temporarily relaxed, allowing the merging of micro-polygons at the same level but slightly spatially dispersed within the view frustum. This reduces the surge in batch numbers caused by rapid viewpoint rotation. Simultaneously, the merged batch information is stored in the GPU constant buffer, containing the world transformation matrix, material parameters, and level attributes, for the shader to access as needed. To reduce visual jumps and rendering call fluctuations caused by LOD switching, a smooth transition phase is inserted before the batch is submitted to the rendering pipeline. When a micro-polygon is detected to be in phase... When the prediction level changes between adjacent frames, the mesh is not switched immediately. Instead, the geometry is gradually transitioned through vertex shader interpolation in the next 2 to 3 frames. The transition weight is calculated based on the time difference between frames and the difference in level to ensure smooth shape changes. At the same time, the drawing call fluctuation suppression mechanism monitors the number of DrawCalls in each frame in real time. If the change rate of DrawCall count between adjacent frames exceeds 20%, the granularity of batch merging and the upper limit of the number of micro-polygons in the group are automatically adjusted. If necessary, some low-level batches are merged into fewer large batches to stably submit the load. All processing is completed in the preprocessing stage within the rendering thread to ensure that the total processing time per frame is controlled within 3 milliseconds, maintaining a high frame rate while ensuring visual coherence and rendering efficiency. Step 4 also includes: establishing a view-level association cache table to record the optimal micropolygon combination and batch configuration under each view, effectively utilizing the computation cache, significantly reducing the real-time computation overhead under the same or similar view, and using a double buffer mechanism to progressively update the micropolygon batch during continuous view switching to avoid screen stuttering. Through asynchronous data preparation and smooth switching, it ensures the high smoothness of the rendered screen when the view changes. It supports efficient submission of batch micropolygons in UE through the Niagara system and in Unity through GPU instantiation, making full use of the core features of different engines to achieve efficient batch rendering across platforms and improve overall throughput. Furthermore, during implementation, a view-level association cache table is constructed and maintained. This table uses view spatial coordinates (longitude, latitude, and altitude) and orientation quaternions as index keys to record the optimized micro-polygon combination schemes and their corresponding batch configuration parameters under that view. Each cache entry contains the following core data: the LOD level distribution matrix of each micro-polygon under that view, the batch partitioning scheme (a list of micro-polygon IDs included in each batch), vertex buffer offset, and pre-calculated spatial continuity grouping identifier. The cache table adopts an LRU eviction policy with a maximum capacity of 5000 records. When a new view query fails to find a match, based on the current view frustum range and scene spatial distribution, an optimal level allocation scheme is generated through real-time calculated hybrid criteria (view distance thresholds: LOD1 is 50 meters, LOD2 is 150 meters, LOD3 is 300 meters; projected area thresholds: 256, 64, and 16 pixels respectively), and batch clustering calculations are performed (maximum 512 micro-polygons per group). The calculation results are synchronously updated to the cache table, and a consistency check is performed on the cache table every frame. To ensure the effectiveness of the buffer, the recorded viewpoint parameters must be within 0.5 meters of the actual camera position and the angle deviation must be less than 2 degrees. A dual-buffering mechanism is used to progressively update micropolygon batches, achieving a smooth rendering transition during continuous viewpoint switching. This mechanism maintains two batch data buffers: the front buffer stores the batch data currently in use for the frame, while the back buffer asynchronously prepares the batch data for the next frame outside the rendering thread. When the viewpoint changes, the corresponding micropolygon batch configuration is retrieved from the viewpoint-level association buffer table or calculated in real time based on the predicted frustum parameters for the next frame. The recombined vertex data (using an interleaved storage format, including position, normals, texture coordinates, and level weights) is written to the back buffer. After the vertical synchronization signal is triggered, buffer swapping is performed, with the swapping delay controlled within 1 millisecond. For batch data that cannot be prepared in the current frame, a progressive update strategy is adopted: smooth transition between batches is achieved through vertex shader interpolation in the following 2 to 3 frames. The transition weight is dynamically calculated based on the inter-frame time difference and level difference (weight coefficient 0.2-0).8) Effectively avoids screen stuttering caused by untimely data preparation; during the rendering submission stage, an optimized batch submission mechanism is adopted for different engine platforms. In Unreal Engine, efficient rendering of micro-polygons is achieved by integrating the Niagara particle system: each batch is mapped to a Niagara emitter, and the micro-polygon vertex data in the batch is passed to the GPU through a structured buffer. The parallel computing capability of Niagara is used to realize vertex transformation and material parameter interpolation. Each emitter corresponds to a DrawCall, and dynamic instantiation is supported to handle duplicate structures within the same batch. In Unity, GPU instantiation technology is used to implement... The current batch submission method creates a corresponding material property block for each batch, including the world transformation matrix, color parameters, and layer blending weights. Up to 1023 instances are submitted at once via the `Graphics.DrawMeshInstanced` interface. Vertex data is indexed using the instance ID in the shader. Both implementations support dynamic batching: when adjacent batches are detected to have identical material properties and continuous spatial positions, they are automatically merged into a larger drawing batch, reducing the number of DrawCalls per frame by more than 60%, while ensuring that GPU memory bandwidth usage does not exceed 40% of the total video memory bandwidth, guaranteeing smooth rendering for multi-view inspections in large-scale power grid scenarios. Step 5 specifically includes: dividing the scene into three layers—core, transition, and background—based on the camera's field of view center angle and the device's fault status, and assigning them progressively decreasing rendering priorities to effectively focus on key areas and improve visual attention concentration. Each frame dynamically adjusts the number of micro-polygons in each layer according to the real-time frame rate and video memory usage, prioritizing the complete rendering of the core layer and faulty areas, ensuring that key areas always maintain high-fidelity rendering quality when resources are scarce. When the frame rate is lower than the preset frame rate threshold, the number of micro-polygons in the background layer is automatically reduced, and visual continuity is maintained through interpolation algorithms, significantly alleviating performance pressure and avoiding screen stuttering and visual breaks. Furthermore, based on the camera's field of view center angle and the device's malfunction status, the scene is divided into three rendering layers: the core layer, the transition layer, and the background layer, each with a progressively decreasing rendering priority. The layering is based on the following: the area extending 30 degrees to each side of the camera's view frustum center axis is designated as the core layer; the area extending from the core layer to a 60-degree angle is the transition layer; and the area beyond the 60-degree angle is the background layer. Additionally, if any device in the scene is malfunctioning, regardless of its current layer level, it is automatically promoted to the core layer for rendering. The initial micropolygon allocation ratio for each layer is as follows: the core layer retains all micropolygons, the transition layer retains 60%, and the background layer retains 40%. This is achieved through real-time calculation of each micropolygon... The relative angle between polygons and the camera viewpoint, along with device status indicators, are dynamically categorized into corresponding layers. The layer index buffer is updated before each frame rendering. Layer data is stored in binary format in a GPU constant buffer, accessible to the shader via instance ID index, ensuring real-time and accurate layer determination. Real-time frame rate and GPU memory usage are monitored synchronously before each frame rendering, and the number of micro-polygons in each layer is dynamically adjusted based on preset thresholds to prioritize the rendering integrity of core layers and faulty areas. The frame rate sampling period is 100 milliseconds, and memory usage is obtained through a graphics API query. The adjustment strategy is as follows: when the frame rate is below 30 frames per second or memory usage exceeds 2GB, the following adjustments are made first: The number of micropolygons in the background layer is reduced by 30% of the current number. If resources are still scarce, the number in the transition layer is reduced by 15%. All reduction operations select micropolygons to be removed using a combination of random sampling and importance weighting to ensure uniform visual distribution. Micropolygons containing faulty devices are marked as protected objects and will be retained in any resource adjustments. The maximum number of micropolygons in each layer after adjustment is as follows: no more than 50,000 in the core layer, no more than 30,000 in the transition layer, and no more than 10,000 in the background layer. Adjustment instructions are executed asynchronously outside the rendering thread via the compute shader to avoid blocking the main rendering pipeline. When the system detects that the real-time frame rate is consistently lower than... When the preset threshold of 25 frames per second is reached, a further reduction mechanism for the number of micro-polygons in the distant view layer is automatically triggered. The reduction process adopts a progressive algorithm: the target reduction ratio (50% of the current number) is calculated, and the number of micro-polygons is gradually reduced through linear interpolation over 3 to 5 consecutive frames to avoid visual abrupt changes caused by a sudden drop in the number. At the same time, in order to maintain the visual continuity of the distant view area, interpolation is performed to fill the gaps that may appear due to the reduction: the average color and normal information of the neighboring micro-polygons are used to generate transition pixels through the bilinear interpolation algorithm in the pixel shader to ensure that the distant view layer still maintains a smooth visual performance after simplification. This interpolation process is performed on the GPU, with no additional overhead per frame.With a resolution of 5 milliseconds, all reduction and interpolation parameters are passed to the shader through a unified buffer object, and the interpolation radius can be dynamically adjusted according to scene complexity (the default value is 2 pixels). This ensures the smoothness and visual coherence of the overall image while guaranteeing the rendering quality of the core layer and faulty areas. Step 6 specifically includes: real-time monitoring of rendering pipeline load metrics, including frame rate variance, video memory usage, and number of draw calls, to quickly locate performance bottlenecks, ensure real-time system response, and improve monitoring accuracy. When frame rate jitter or video memory overrun is detected, a micro-polygon simplification mechanism is automatically triggered to reduce the mesh complexity of non-critical areas, effectively alleviate resource pressure, maintain rendering quality in critical areas, avoid screen stuttering, and simultaneously perform shader parameter degradation, disable high-overhead lighting effects, and fall back to the pre-computed lighting model to ensure stable and visually consistent visuals during the inspection process, smoothly transition visual performance, maintain screen continuity, and improve comfort during long-term inspections. Furthermore, during system operation, key load metrics of the rendering pipeline are continuously collected. The frame rate variance is obtained by sampling the frame interval every 100 milliseconds and calculating its standard deviation, with a threshold set at ±3 frames. Memory usage is directly queried via the graphics API, with an upper warning value of 2GB. The number of rendering calls is counted from the rendering command queue, with a peak of no more than 2000 calls per frame. If any metric exceeds the threshold range for two consecutive frames, an abnormal load is identified, triggering an adaptive adjustment process. Monitoring data is temporarily stored in a circular buffer and updated every frame to ensure real-time decision-making. After an abnormal load is triggered, a micro-polygon simplification mechanism is automatically activated. This mechanism performs mesh simplification on non-critical areas (far-view layers and non-faulty devices in transition layers) based on device status and view layer priority. The simplification algorithm uses a progressive mesh simplification based on edge folding. The maximum simplification ratio per frame is 20% to ensure visual continuity. The number of vertices in the simplified mesh is no less than 40% of the original mesh. At the same time, the index buffer and vertex attribute stream are updated. The simplification operation is performed on an independent calculation thread to avoid blocking the rendering pipeline. The processing time per frame is controlled within 2 milliseconds. The shader parameter degradation process is executed synchronously to dynamically adjust the rendering effect to reduce computational overhead. High-overhead lighting effects are gradually turned off, and the model is rolled back to the pre-calculated lighting model. The lighting model switching adopts a gradual transition. The degradation is achieved smoothly through weighted interpolation within 3 to 5 frames. After degradation, the shader uses a simplified version of lighting calculation, retaining only diffuse and ambient light terms. The specular calculation frequency is reduced to once per pixel. All degradation parameters are passed to the GPU through a unified buffer to ensure visual consistency. Finally, the rendering load returns to a stable range, and the image performance remains consistent.
[0021] It should be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.
[0022] 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 method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micro-polygons, characterized in that, Includes the following steps: Step 1: Extract the Gaussian splash model from the power grid scenario, convert it into a dynamic micro-polygon structure in real time, and construct an elastic deformation parameter mapping table based on the power grid equipment type and deformation characteristics to establish a real-time association between the micro-polygon vertices and the physical properties of the Gaussian sphere. Step 2 involves integrating the elastic deformation interpolation algorithm and the micro-polygon dynamic topology update algorithm to adjust the deformation parameters of the Gaussian sphere and the vertex connection structure of the micro-polygon in real time. Specifically, this includes: The algorithm integrates elastic deformation interpolation to calculate Gaussian spherical variables in real time based on wind speed and icing weight parameters, and then interpolates to generate smooth deformation curves. Based on the micropolygon dynamic topology update algorithm, the vertex connection structure of the micropolygon is reorganized according to the position of the Gaussian sphere after deformation, while maintaining the continuity of the wire mesh. The physical state and connection relationship of the micropolygon vertices are updated in each frame. During the oscillation of the conductor, the distance between adjacent Gaussian spheres is detected in real time. If it exceeds the preset threshold, dynamic subdivision or merging of micro-polygons is triggered. The quaternion interpolation algorithm is used to smooth the rotational deformation of the micropolygon, maintaining the visual continuity at the bend of the wire, and a physical constraint solver is introduced to apply stretching and bending constraints to the vertices of the micropolygon. Step 3: Introduce a lighting data streaming synchronization algorithm and a micro-polygon shader dynamic compilation technology to recompile the shader and synchronize the global lighting cache in real time when a power grid fault is triggered. Step 4: For multi-view high-frequency data update scenarios, combine multi-view LOD prediction smoothing algorithm with micro-polygon batch merging rendering technology, predict detail level switching nodes based on view trajectory, and merge adjacent micro-polygon drawing batches. Step 5: Based on the camera's field of view and device status priority, the scene is divided into three layers: core, transition, and distant view. The number of micro-polygons in each layer is dynamically adjusted according to the real-time frame rate and video memory usage, prioritizing the rendering quality of faulty areas and the center of the field of view. Step 6: Continuously monitor the rendering pipeline load and image stability indicators. When frame rate jitter or memory overrun is detected, automatically trigger micropoly simplification and shader parameter degradation.
2. The method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons according to claim 1, characterized in that: Step 1 specifically includes: Gaussian sphere data is extracted from the Gaussian splash model of the power grid, and the position, radius, and elasticity parameters are analyzed in real time based on the cross-engine intermediate data format to generate an initial dynamic micro-polygon mesh. Based on the type of power grid equipment, an elastic deformation parameter mapping table is constructed, mapping the high-density Gaussian sphere of rigid equipment to a high-stiffness micropolygon, and the slender Gaussian sphere of flexible equipment to a deformable micropolygon. Establish a real-time correlation mechanism between the vertices of the micropolygon and the physical properties of the Gaussian sphere, and pass the deformation coefficient, density, and elastic modulus through the vertex shader.
3. The method for accelerating layered rendering of a Gaussian splashing model of a power grid based on dynamic micropolygons according to claim 1, characterized in that: Step 3 specifically includes: An illumination data streaming synchronization algorithm is introduced to obtain ambient light, shadow, and reflection data from the global illumination system in real time when a fault is triggered. By using dynamic compilation technology for micropolygon shaders, custom shader code containing highlighted outlines and blinking effects is generated based on the fault type. The compiled shader is injected into the rendering pipeline in sync with the global illumination cache, so that the faulty area is seamlessly integrated with the ambient lighting effects.
4. The method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons according to claim 3, characterized in that: Step 3 also includes: During the dynamic compilation of the shader, color gradient functions and transparency blending parameters are injected in real time to achieve a smooth transition from the normal state to the highlighted state in the faulty area. By fusing optical cache pre-computation with real-time probes, the high-light reflection of the fault area and the ambient shadow are interpolated and synthesized at multiple levels, and the dynamic illumination response curve of the fault area is supported for adjustment.
5. The method for accelerating layered rendering of a Gaussian splashing model of a power grid based on dynamic micro-polygons according to claim 1, characterized in that: Step 4 specifically includes: Based on the multi-view LOD prediction smoothing algorithm, the detail level nodes that may switch in the next 3-5 frames are pre-calculated according to the camera movement trajectory. By using micropolygon batch merging rendering technology, micropolygons of the same level within adjacent view frustums are merged into a single rendering batch. The batch merging strategy is dynamically adjusted during viewpoint switching to reduce rendering call fluctuations caused by LOD jumps.
6. The method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons according to claim 5, characterized in that: Step 4 also includes: Establish a view-level association cache table to record the optimal micropolygon combination and batch configuration under each view; During continuous perspective switching, a double buffering mechanism is used to progressively update micropoly batches to avoid screen stuttering.
7. The method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons according to claim 1, characterized in that: Step 5 specifically includes: Based on the camera's field of view center angle and the equipment's fault status, the scene is divided into three layers: core, transition, and background, and each layer is assigned a rendering priority that decreases progressively. Each frame dynamically adjusts the number of micro-polygons in each layer based on the real-time frame rate and video memory usage, prioritizing the complete rendering of the core layer and faulty areas; When the frame rate is lower than the preset frame rate threshold, the number of micro-polygons in the distant layer is automatically reduced, and visual continuity is maintained through an interpolation algorithm.
8. The method for accelerating layered rendering of a Gaussian splash model of a power grid based on dynamic micropolygons according to claim 1, characterized in that: Step 6 specifically includes: Real-time monitoring of rendering pipeline load metrics, including frame rate variance, video memory usage, and number of draw calls, to quickly pinpoint performance bottlenecks; When frame rate jitter or video memory overrun is detected, the micro-polygon simplification mechanism is automatically triggered. Simultaneously perform shader parameter degradation, turn off high-overhead lighting effects, and fall back to the pre-computed lighting model to ensure stable visuals and consistency during the inspection process.
Citation Information
Patent Citations
High-fidelity large-scale scene rendering method, system and equipment based on Gaussian splashing and medium
CN119295621A
Physical attribute inversion and three-dimensional reconstruction method based on Gaussian splashing and micro rendering
CN121482292A
