Dynamic modeling method and system for 3D home scene

Abstract

The application relates to the technical field of dynamic modeling, and discloses a dynamic modeling method and system for a 3D home scene, which comprises the following steps: acquiring real-time interactive displacement vector data; when the capture frequency of the real-time interactive displacement vector data exceeds a fixed refresh rate threshold, fusing into a weighted mixed deformation vector through a cyclic temporary storage queue; calculating a local vertex attribute matrix correction value according to the weighted mixed deformation vector, and performing matrix internal superposition transformation on the local vertex attribute matrix correction value and a time sequence topological offset matrix to complete time sequence difference compensation correction; and transmitting the local vertex attribute matrix correction value into a sub-buffer area overwrite interface through a sparse vertex array slice stored in an interleaved structure to perform local in-situ overwrite writing, and updating a grid topological form, wherein the application limits the recalculation cost within a local slice range, reduces the throughput pressure of a display memory bus, eliminates time sequence lag, and avoids picture flickering.

Description

Technical Field

[0001] This invention relates to a dynamic modeling method and system for 3D home scenes, belonging to the field of dynamic modeling technology. Background Technology

[0002] The current general architecture for online 3D scene reconstruction and graphics rendering adopts a tree-like hierarchical organization structure based on the scene graph. It distributes mesh vertex data and material properties by traversing the spatial node tree, and, in conjunction with the multi-stage shader pipeline of the rendering pipeline, realizes coordinate transformation and lighting calculation of 3D geometric entities in virtual space. In the graphics context, the vertex attribute matrix of the geometric model contains coordinate data, normal vectors, and texture coordinates, which are typically uploaded to the video memory buffer during the initialization phase. The rendering pipeline reads the vertex attribute array with a fixed step size, driving the hardware rasterization processor to continuously draw the geometric shape, thus creating an online dynamic scene. In this scenario, due to frequent editing operations such as wall translation, partition changes, and dragging of door and window openings, the mesh topology undergoes continuous local changes. Because of the adjacency topology constraints between meshes, changes in a single component cause synchronous deformation of multiple sets of mesh data. In this interactive scenario, traditional frameworks lack the ability to identify local deformation boundaries. Once a local shape shifts, the system needs to re-traverse the node tree structure, recalculate the mesh coordinates, and send a full update command to the video memory, causing the video memory bus to experience saturation throughput pressure. This results in intermittent screen stuttering or display abnormalities in the graphics rendering pipeline due to data congestion.

[0003] To alleviate memory latency, common improvement strategies include increasing memory capacity or setting timers to lengthen the data capture step size. However, increasing the cache cannot eliminate the recalculation redundancy caused by full mesh reconstruction; instead, it increases resident memory usage. Limiting the data capture frequency affects the continuity of deformation trajectories, leading to a decrease in the real-time performance of interactive responses. This causes buffer refresh misalignment and rendering tearing in the graphics context during asynchronous event loops, failing to resolve the contradiction between local high-frequency variations and global memory recalculation. In addition to hardware bottlenecks such as memory throughput and bus overload, software-level control methods and rendering scheduling strategies also have shortcomings, making it difficult to adaptively cope with dynamic high-frequency local topology variations. For example, the Chinese invention patent with authorization announcement number CN111369656B... A progressive real-time rendering method for editable large scenes based on WebGL was proposed. By constructing a hierarchical bounding box spatial structure, a control method was adopted to distribute the large-scale scene rendering task across multiple frames of progressive rendering, thereby controlling the time consumption of a single frame and improving the smoothness of interaction. However, its control logic implicitly relies on the underlying objective properties that the scene structure is relatively static or only undergoes conventional view frustum changes within the multi-frame rendering cycle. When faced with strong dynamic deformation of local meshes such as local wall anomalies and high-frequency dragging of partitions in online home dynamic editing, the strategy of diluting rendering across frames and forcibly spreading the computational pressure leads to cross-frame time lag and visual ghosting in geometric topology reconstruction, causing obvious disconnection of deformation trajectory. It fails to solve the contradiction between local high-frequency anomalies and global video memory recalculation.

[0004] Therefore, the technical problem to be solved by this invention is how to determine the minimum topological influence range of deformation, achieve in-situ accurate coverage of the video memory buffer through byte offset control of the local memory array, and achieve the merging and blanking of the displacement vector within the time domain window under high-frequency concurrency. Summary of the Invention

[0005] To address the problems in the background art, the technical solution of the present invention is as follows: A dynamic modeling method for 3D home scenes, comprising the following steps:

[0006] Step S1: Obtain real-time interactive displacement vector data representing the editing trajectory of the 3D scene;

[0007] Step S2: When the capture frequency of real-time interactive displacement vector data exceeds the determined refresh rate threshold, the real-time interactive displacement vector data is cached in a circular temporary storage queue, and the weighted attenuation coefficient of each real-time interactive displacement vector data in the circular temporary storage queue is extracted and weighted summation is performed to merge it into a weighted hybrid deformation vector of spatial displacement dimension.

[0008] Step S3: Calculate the local vertex attribute matrix correction value containing three-dimensional coordinate components, normal vector components, and texture coordinate components based on the weighted hybrid deformation vector, and calculate the temporal topology offset matrix according to the frame interval delay of the graphics context. Use the temporal topology offset matrix as an incremental matrix to perform intramatrix superposition transformation with the local vertex attribute matrix correction value to complete the temporal difference compensation correction.

[0009] Step S4: Using the sparse vertex array slices stored in an interleaved structure, the local vertex attribute matrix correction values ​​after time difference compensation are passed as input arrays to the sub-buffer overwrite interface of the WebGL context. The target video memory buffer is addressed according to the determined starting byte offset to perform local in-situ overwrite, driving the graphics processor to reconstruct and update the deformed 3D model mesh topology using the target mesh vertex shader and the corresponding fragment shader.

[0010] Preferably, step S2 includes the following sub-steps: Step S21, within each time sliding window, assign a weighted attenuation coefficient that monotonically decreases with the advancement of the frame sequence time to each real-time interactive displacement vector data in the circular temporary queue; Step S22, obtain the topological displacement increment in each real-time interactive displacement vector data, and multiply the topological displacement increment with the corresponding weighted attenuation coefficient to generate multiple sets of weighted displacement matrices; Step S23, merge and accumulate the multiple sets of weighted displacement matrices in the spatial displacement dimension to form a weighted hybrid deformation vector.

[0011] Preferably, step S3 includes the following sub-steps: step S31, obtaining the frame interval time data between the current rendering frame and the adjacent preceding frame; step S32, calculating the asynchronous delay time for updating video memory data based on the frame interval time data, and establishing a timing topology offset matrix based on the asynchronous delay time for updating video memory data.

[0012] Preferably, the method further includes the following steps: Step S5, when it is identified that the mesh topology change caused by the real-time interactive displacement vector data belongs to the local translation transformation of the preset repeating substructure in the scene, the static basic geometry mesh data stored in the video memory is locked, and the recalculation branch of the corresponding component mesh is closed; the updated local vertex attribute matrix correction value is directly written into the vertex shader attribute array of the graphics hardware as the instance transformation matrix, driving the graphics processor to complete the single-batch instantiation rendering update of the repetitive substructure.

[0013] Preferably, step S4 includes the following sub-steps: step S41, addressing the current video memory buffer through the binding of the WebGL context; step S42, calculating the starting byte offset of the local vertex attribute matrix correction value in the video memory space arrangement; step S43, passing the starting byte offset as the addressing reference to the sub-buffer overwrite interface, and overwriting the local vertex attribute matrix correction value containing the three-dimensional coordinate components, normal vector components and texture coordinate components.

[0014] Preferably, the method further includes the following steps: Step S6, during a continuous interaction cycle, record the rate of change of the modulus of the weighted hybrid deformation vector to generate a time-series evolution dataset; Step S7, extract the decay features in the time-series evolution dataset and calculate the mesh convergence index; Step S8, when the mesh convergence index reaches a fixed stable threshold, slow down the overwrite frequency of the sub-buffer overwrite interface and synchronously update the global memory topology layout.

[0015] Preferably, in the sparse vertex array slice stored in an interleaved structure, the attribute data of a single vertex is arranged continuously in the video memory space, and the data arrangement order inside is that the three-dimensional coordinate components are adjacent to the normal vector components, and the normal vector components are adjacent to the texture coordinate components.

[0016] Preferably, the starting byte offset calculated in step S42 has a spatial addressing step size equal to the total number of bytes of attribute data for a single vertex.

[0017] Preferably, the data acquisition, temporary storage, matrix operation, and overwrite in steps S1 to S4 are completed by the web page graphics rendering engine driven by the script logic generated through compilation.

[0018] A dynamic modeling system for 3D home scenes, comprising a method for dynamic modeling of 3D home scenes, including:

[0019] The data acquisition unit is used to acquire real-time interactive displacement vector data that characterizes the editing trajectory of the 3D scene; the data fusion unit, coupled with the data acquisition unit, is used to cache the real-time interactive displacement vector data to a circular temporary storage queue when the acquisition frequency of the real-time interactive displacement vector data exceeds a certain refresh rate threshold, and extract the weighted attenuation coefficient of each real-time interactive displacement vector data in the circular temporary storage queue within the time sliding window, perform weighted summation operation, and fuse it into a weighted hybrid deformation vector of spatial displacement dimension.

[0020] The difference correction unit, coupled with the data fusion unit, is used to calculate the local vertex attribute matrix correction value containing three-dimensional coordinate components, normal vector components and texture coordinate components based on the weighted hybrid deformation vector, and to calculate the temporal topology offset matrix based on the frame interval delay of the graphics context. The temporal topology offset matrix is ​​used as the incremental matrix and the local vertex attribute matrix correction value is superimposed within the matrix to complete the temporal difference compensation correction.

[0021] The mesh update unit, coupled with the difference correction unit, is used to slice the sparse vertex array stored in an interleaved structure. It takes the local vertex attribute matrix correction value after time-series difference compensation as the input array and passes it to the sub-buffer overwrite interface of the WebGL context. It addresses the target video memory buffer according to the determined starting byte offset and performs local in-situ overwrite. It drives the graphics processor to reconstruct the updated 3D model mesh topology using the target mesh vertex shader and the corresponding fragment shader.

[0022] Compared with the prior art, the beneficial effects of the present invention are:

[0023] 1. In the dynamic modeling of 3D home scenes, the minimum geometric variation boundary of the component to be deformed is locked by the local regulated topological subgraph of the 3D mesh vertices. A sequence of directly adjacent vertex index image intervals is established in the graphics context buffer, so that the static components outside the sequence maintain the initial spatial form. This spatial boundary constraint transmission mechanism based on the adjacency matrix changes the reconstruction method of full traversal of the traditional scene tree. It limits the data upload and recalculation overhead of the graphics processor to the local slice range, reduces the throughput pressure of the graphics hardware memory bus, and enables the high-density mesh of large apartments to maintain a stable mesh reshaping response state during continuous deformation interaction.

[0024] 2. When calculating the local new vertex vector based on the topological displacement increment, a sparse vertex array slice stored in an interleaved structure is used in conjunction with the WebGL context's sub-buffer overwrite interface to specify the starting byte offset. No changes are made to the global memory layout. The local vertex attribute matrix correction values, which include 3D coordinate components, normal vector components, and texture coordinate components, are directly overwritten and updated in situ. At the same time, a temporal topological offset matrix is ​​generated by combining the frame accumulation delay of the graphics context. Feedforward compensation is introduced to the correction values ​​to eliminate the real-time transmission lag of physical deformation trajectories in the graphics buffer and avoid screen flickering in high-frequency editing.

[0025] 3. Under concurrent conditions where the frequency of interactive vector data capture exceeds the preset refresh rate threshold, interactive vectors are cached through a circular temporary queue maintained in memory. Instead of triggering a one-way video memory overwrite for each individual arriving interactive vector, the weight decay trend of each interactive vector in the circular temporary queue within the time-domain window is extracted. Multiple sets of continuous topological displacement increments are merged and fused into a set of predicted fused deformation vectors on a one-dimensional scale. The video memory buffer is then rewritten in situ using this fused deformation vector, thereby offsetting the processing performance loss caused by the synchronization mismatch between the non-blocking asynchronous event loop and the hardware state machine buffer. This ensures that the entire process of mesh geometry evolution under high-frequency concurrent editing remains continuous and smooth. Attached Figure Description

[0026] Figure 1 This is a flowchart illustrating the overall process of the dynamic modeling method for 3D home scenes according to the present invention.

[0027] Figure 2 This is a functional structure diagram of the dynamic modeling system for 3D home scenes of the present invention.

[0028] The objectives, features, and advantages of this invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0029] The technical solutions of the embodiments of this application will be clearly described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of this application are within the scope of protection of this application.

[0030] A dynamic modeling method for 3D home scenes includes the following steps:

[0031] Step S1: Obtain real-time interactive displacement vector data representing the editing trajectory of the 3D scene;

[0032] Step S2: When the capture frequency of real-time interactive displacement vector data exceeds the determined refresh rate threshold, the real-time interactive displacement vector data is cached in a circular temporary storage queue, and the weighted attenuation coefficient of each real-time interactive displacement vector data in the circular temporary storage queue is extracted and weighted summation is performed to merge it into a weighted hybrid deformation vector of spatial displacement dimension.

[0033] Step S3: Calculate the local vertex attribute matrix correction value containing three-dimensional coordinate components, normal vector components, and texture coordinate components based on the weighted hybrid deformation vector, and calculate the temporal topology offset matrix according to the frame interval delay of the graphics context. Use the temporal topology offset matrix as an incremental matrix to perform intramatrix superposition transformation with the local vertex attribute matrix correction value to complete the temporal difference compensation correction.

[0034] Step S4: Using sparse vertex array slices stored in an interleaved structure, the local vertex attribute matrix correction values ​​after time difference compensation are passed as input arrays to the sub-buffer overwrite interface of the WebGL context. The target video memory buffer is addressed according to the determined starting byte offset for local in-situ overwrite. The target mesh vertex shader and fragment shader of the graphics processor are called to reconstruct the mesh topology and update the rendering of the deformed 3D model.

[0035] Preferably, step S2 includes the following sub-steps: Step S21, within each time sliding window, assign a weighted attenuation coefficient that monotonically decreases with the advancement of the frame sequence time to each real-time interactive displacement vector data in the circular temporary queue; Step S22, obtain the topological displacement increment in each real-time interactive displacement vector data, and multiply the topological displacement increment with the corresponding weighted attenuation coefficient to generate multiple sets of weighted displacement matrices; Step S23, merge and accumulate the multiple sets of weighted displacement matrices in the spatial displacement dimension to form a weighted hybrid deformation vector.

[0036] Preferably, step S3 includes the following sub-steps: step S31, obtaining the frame interval time data between the current rendering frame and the adjacent preceding frame; step S32, calculating the asynchronous delay time for updating video memory data based on the frame interval time data, and establishing a timing topology offset matrix based on the asynchronous delay time for updating video memory data.

[0037] Preferably, the method further includes the following steps: Step S5, when it is identified that the mesh topology change caused by the real-time interactive displacement vector data belongs to the local translation transformation of the preset repeating substructure in the scene, the static basic geometry mesh data stored in the video memory is locked, and the recalculation branch of the corresponding component mesh is closed; the updated local vertex attribute matrix correction value is directly written into the vertex shader attribute array of the graphics hardware as the instance transformation matrix, driving the graphics processor to complete the single-batch instantiation rendering update of the repetitive substructure.

[0038] Preferably, step S4 includes the following sub-steps: step S41, addressing the current video memory buffer through the binding of the WebGL context; step S42, calculating the starting byte offset of the local vertex attribute matrix correction value in the video memory space arrangement; step S43, passing the starting byte offset as the addressing reference to the sub-buffer overwrite interface, and overwriting the local vertex attribute matrix correction value containing the three-dimensional coordinate components, normal vector components and texture coordinate components.

[0039] Preferably, the method further includes the following steps: Step S6, during a continuous interaction cycle, record the rate of change of the modulus of the weighted hybrid deformation vector to generate a time-series evolution dataset; Step S7, extract the decay features in the time-series evolution dataset and calculate the mesh convergence index; Step S8, when the mesh convergence index reaches a fixed stable threshold, slow down the overwrite frequency of the sub-buffer overwrite interface and synchronously update the global memory topology layout.

[0040] Preferably, in the sparse vertex array slice stored in an interleaved structure, the attribute data of a single vertex is arranged continuously in the video memory space, and the data arrangement order inside is that the three-dimensional coordinate components are adjacent to the normal vector components, and the normal vector components are adjacent to the texture coordinate components.

[0041] Preferably, the starting byte offset calculated in step S42 has a spatial addressing step size equal to the total number of bytes of attribute data for a single vertex.

[0042] Preferably, the data acquisition, temporary storage, matrix operation, and overwrite in steps S1 to S4 are completed by the web page graphics rendering engine driven by the script logic generated through compilation.

[0043] A dynamic modeling system for 3D home scenes, comprising a method for dynamic modeling of 3D home scenes, including:

[0044] The data acquisition unit is used to acquire real-time interactive displacement vector data that characterizes the editing trajectory of the 3D scene; the data fusion unit, coupled with the data acquisition unit, is used to cache the real-time interactive displacement vector data to a circular temporary storage queue when the acquisition frequency of the real-time interactive displacement vector data exceeds a certain refresh rate threshold, and extract the weighted attenuation coefficient of each real-time interactive displacement vector data in the circular temporary storage queue within the time sliding window, perform weighted summation operation, and fuse it into a weighted hybrid deformation vector of spatial displacement dimension.

[0045] The difference correction unit, coupled with the data fusion unit, is used to calculate the local vertex attribute matrix correction value containing three-dimensional coordinate components, normal vector components and texture coordinate components based on the weighted hybrid deformation vector, and to calculate the temporal topology offset matrix based on the frame interval delay of the graphics context. The temporal topology offset matrix is ​​used as the incremental matrix and the local vertex attribute matrix correction value is superimposed within the matrix to complete the temporal difference compensation correction.

[0046] The mesh update unit, coupled with the difference correction unit, is used to slice the sparse vertex array stored in an interleaved structure. It takes the local vertex attribute matrix correction value after time-series difference compensation as the input array and passes it to the sub-buffer overwrite interface of the WebGL context. It addresses the target video memory buffer according to the determined starting byte offset and performs local in-situ overwrite. It drives the graphics processor to reconstruct the updated 3D model mesh topology using the target mesh vertex shader and the corresponding fragment shader.

[0047] Example 1: In a 3D home scene with various wall constraints and furniture placement, the system performs real-time modeling of the user's furniture dragging operation. When the user initiates a furniture position movement request through the front-end interface, the interaction control module intercepts the operation and encapsulates the furniture identifier, starting coordinates, boundary parameters of adjacent furniture, and drag displacement vector into real-time interactive displacement vector data. As the user's dragging speed increases, the capture frequency of the real-time interactive displacement vector data exceeds the system's preset 60Hz refresh rate threshold. The system then activates the data fusion unit, storing the displacement vector data captured in each frame into a memory circular temporary storage queue. The data fusion unit assigns a time sliding window weighted attenuation coefficient to each vector data in the queue, with recent data based on a higher coefficient and older data based on a lower attenuation coefficient, to calculate a weighted hybrid deformation vector in the spatial displacement dimension.

[0048] The interpolation correction unit acquires the time interval between the current rendering frame and the previous frame, calculates the asynchronous delay time for memory data updates, and constructs a temporal topology offset matrix based on this. This matrix is ​​then superimposed with the local vertex attribute matrix correction values, which include furniture 3D coordinate components, normal vector components, and texture coordinate components, calculated based on a weighted hybrid deformation vector. This process completes the temporal interpolation compensation correction. Specifically, the data column structure of the temporal topology offset matrix completely corresponds to the local vertex attribute matrix correction values. Only the columns corresponding to the 3D coordinate components in this offset matrix are filled with geometric displacement compensation increments calculated based on the asynchronous delay time for memory data updates and spatial displacement velocity vectors, while the columns corresponding to the normal vector components and texture coordinate components remain zero. During the matrix superposition transformation, corresponding components are added element-wise according to the same matrix type, ensuring that the temporal interpolation compensation only applies to the spatial position of the vertices, thus preventing dimensional contamination of the object's material texture coordinates and normal directions during the superposition process. By combining the weighted hybrid deformation vector with the current rendering frame interval time data, and considering the past update time delay data, a first-order forward difference operation is performed on the weighted hybrid deformation vector to generate the temporal spatial displacement velocity vector of the adjusted mesh vertex. This vector, along with the delay data, is converted into a geometric displacement compensation increment column vector containing three axial compensation values ​​and filled into the third column of the matrix. The other columns of data corresponding to the normal vector component and texture coordinate component are kept at 0. Finally, this matrix is ​​added to the local vertex attribute matrix correction value at the corresponding element positions of the same type matrix to complete the spatial position matrix calibration including time deviation feedforward compensation. Based on the compensated data, the mesh update unit calculates the starting byte offset of the furniture to be updated in the video memory buffer and writes the sparse vertex array slice in the video memory in situ through the WebGL sub-buffer overwrite interface. Based on the updated data, the graphics processor drives the vertex shader and fragment shader to complete the reconstruction and rendering of the scene mesh topology, realizing the real-time smooth displacement of the furniture in the dynamic modeling process.

[0049] Example 2: This experiment aims to verify the computational stability and rendering throughput efficiency of the system for synchronous interoperability of multiple components in dynamic modeling of 3D home scenes. The experimental platform consists of a graphics workstation equipped with 6GB of video memory. A WebGL off-screen rendering context with preloading capabilities is used to simulate a real browser-based home design environment. The experimental scene includes 50 pre-set window components of identical specifications, with an initial mesh data of 120,000 vertices. To verify the stability of the technical solution in a real industrial environment, the experiment simulates high-frequency concurrent interaction. During the experiment, the system recognizes synchronous translation operations initiated by the user on a row of window components. The interaction control module transmits component identifiers, starting coordinates, adjacent boundary parameters, and displacement directions... The data is encapsulated as real-time interactive displacement vector data, triggering the mesh topology update logic. This invention's sample utilizes a multi-instance reuse compensation mechanism. When the interaction frequency exceeds a 60Hz threshold, the difference correction unit calculates the local vertex attribute matrix correction value and converts it into an instance transformation matrix. This matrix is ​​then updated to the vertex shader instance attribute array of the graphics hardware via the WebGL interface. Specifically, for overall translational interactions belonging to repeating substructures, the difference correction unit extracts the statistical center value of the spatial displacement of each vertex coordinate component from the local vertex attribute matrix correction value. This single spatial displacement vector is directly written as a translation component into the corresponding 4x4 affine transformation matrix of the repeating component, while the rotation and scaling components remain as identity matrices. The system uses this state to perform statistical dimensionality reduction on the microscopic local modifications containing a large number of vertices, transforming them into a macroscopic instance transformation matrix that uniformly controls the spatial displacement of the entire mesh geometry. This completes the feature transformation mapping from per-vertex data to per-instance attributes. When translating repeating substructures, the data fusion unit extracts the coordinate displacement vectors of each vertex and calculates their spatial distribution variance. When the variance is equal to 0, the difference correction unit writes this vector as the translation increment into the corresponding 4x4 affine transformation matrix to generate an instance transformation parameter array, driving the graphics hardware to directly transform the overall spatial coordinates. When the variance is greater than 0, the system closes the instance rendering update branch and instead distributes topological weight vectors containing local deformation features through the vertex shader's custom attribute array. To evaluate the technical effectiveness, a multi-dimensional comparison system including a control group was designed to drive the graphics processing unit (GPU) to perform parallel computation of vertex coordinate positions for local fine-tuning. The control group adopted a full scene tree traversal reconstruction scheme. Each translation operation triggered a full recalculation of the mesh topology of all window components and a memory buffer overwrite. Key performance indicators recorded in the experiment included memory buffer overwrite frequency, GPU bus bandwidth utilization, and vertex coordinate update jitter standard deviation. The experimental results showed that within 20 consecutive translation interaction test cycles, the average memory buffer overwrite frequency of the present invention's sample group was 12 times per second, the GPU bus bandwidth utilization was stable between 35% and 42%, and the vertex coordinate update jitter standard deviation was 0.The average memory buffer overwrite frequency was 240 times per second, the graphics processor bus bandwidth utilization fluctuated between 85% and 92%, and the standard deviation of vertex coordinate update jitter was 0.045 mm under the same operating conditions.

[0050] The above data confirms that when component changes involve local translation transformations of pre-defined repeating substructures, reusing the basic geometric mesh through instance transformation matrices can cut off redundant mesh recalculation links. As the frequency of translation operations increases, the number of times the video memory buffer is overwritten in the comparison sample group increases linearly, causing logical lag in the graphics rendering pipeline. The sample group of this invention maintains low bandwidth usage and vertex jitter under frequent interaction conditions through a multi-instance reuse compensation mechanism. When the weighted hybrid deformation vector magnitude change rate shows that the mesh convergence index reaches a stable threshold of 0.001, the system automatically slows down the overwrite frequency of the sub-buffer overwrite interface and updates the global video memory topology layout synchronously. Furthermore, the specific calculation logic of the mesh convergence index is as follows: the system continuously collects the weighted hybrid deformation vector of each rendering frame in the current interaction cycle and calculates the absolute value of the difference between the vector magnitude of the current frame and the adjacent previous frame. The ratio of this absolute value to the corresponding rendering frame interval time is the current magnitude change rate. The system maintains a time-domain sliding window covering 10 consecutive sampling points in memory, performs an arithmetic mean calculation on the magnitude change rate within the window, and obtains a dimensionless value. The mean is defined as the mesh convergence index, used to quantitatively characterize the dynamic stability trend of the mesh topology in the time domain. When calculating the mesh convergence index, the data fusion unit collects the weighted hybrid deformation vector of each rendering frame in the current interaction cycle, calculates the absolute value of the difference between the vector magnitude of the current frame and the adjacent previous frame, and uses the ratio of this difference to the interval time of the corresponding rendering frame as the current magnitude change rate. The system maintains a time-domain sliding window covering 10 consecutive sampling points in memory and calculates the arithmetic mean of the change rate within the window. When the obtained dimensionless mean is lower than the preset stability threshold of 0.001 for three consecutive rendering frames, the web graphics rendering engine suspends the high-frequency in-situ overwrite operation of the sub-buffer overwrite interface and instead calls the full data cache overwrite interface of the web graphics library in the browser page idle callback interface. The vertex data resident in the memory circular queue is fully uploaded to the static video memory buffer at once, completing the global video memory topology layout baseline synchronization and clearing the local overwrite pointer. The experimental results show that the instance transformation mechanism based on local mesh reconstruction can effectively reduce the graphics processor bus load and improve the real-time response stability of dynamic modeling.

[0051] Example 3: This example combines Figures 1 to 2 This section describes the dynamic modeling methods and systems for 3D home scenes, such as... Figure 1As shown, the dynamic modeling method for 3D home scenes includes four consecutive operation steps. Step S1 is used to acquire real-time interactive displacement vector data representing the editing trajectory of the 3D scene. Step S2 is initiated when the capture frequency of the real-time interactive displacement vector data exceeds a determined refresh rate threshold. The real-time interactive displacement vector data is cached in a circular temporary queue, and the weighted attenuation coefficients of each real-time interactive displacement vector data in the circular temporary queue are extracted and weighted summed to form a weighted hybrid deformation vector of spatial displacement dimension. Step S3 is then performed to calculate the local vertex attribute matrix containing 3D coordinate components, normal vector components, and texture coordinate components based on the weighted hybrid deformation vector. The positive value is calculated, and the temporal topology offset matrix is ​​calculated based on the frame interval delay of the graphics context. The temporal topology offset matrix is ​​used as an incremental matrix and the local vertex attribute matrix correction value is superimposed on the matrix to complete the temporal difference compensation correction. Finally, through step S4, the local vertex attribute matrix correction value after temporal difference compensation is passed as an input array to the sub-buffer overwrite interface of the WebGL context through the sparse vertex array slice stored in the interleaved structure. The target video memory buffer is addressed according to the determined starting byte offset to perform local in-situ overwrite, driving the graphics processor to reconstruct and update the deformed 3D model mesh topology using the target mesh vertex shader and the corresponding fragment shader.

[0052] like Figure 2 As shown, four parallel processing units converge at the core terminal node of dynamic modeling for 3D home scenes. The data acquisition unit performs the operation of acquiring real-time interactive displacement vector data. The data fusion unit is triggered when the capture frequency exceeds a fixed refresh rate threshold. Based on the weighted attenuation coefficient within the extracted time sliding window, it performs hybrid deformation vector fusion processing of spatial displacement dimension. The difference correction unit is responsible for calculating the correction value of local vertex attribute matrix and performing superposition transformation using temporal topology offset matrix. The mesh update unit, based on the underlying data organization form of sparse vertex array slice interleaved structure storage, passes the target matrix to the sub-buffer interface for in-situ overwrite.

[0053] Example 4: In an interactive application for real-time dynamic modeling of high-density home scenes, the system processes user requests to edit furniture groups containing complex geometric structures in real time. When the interactive control module receives concurrent drag-and-drop operations on multiple components, the system faces issues such as memory buffer read / write conflicts and scene topology reconstruction lag caused by high-frequency interactive requests. To achieve stable response during the modeling process, the system locks the geometric boundaries of the currently operated component through a vertex index mapping sequence during the interactive triggering phase. Specifically, the system extracts the minimum bounding box vertex set affected by the interoperation, establishes a corresponding sparse vertex array slice, and defines it as the target data object for this dynamic modeling operation. The interactive control module calculates real-time displacement increment data by capturing the sampling point coordinate sequence of the user's input device. Under conditions where the continuous interactive sampling frequency exceeds 60Hz, to eliminate the interference of input jitter on the modeling results, the data fusion unit uses a time-weighted sliding window to smooth the displacement increment data, defining... The smoothed displacement vector. In order to be in The original displacement increment sampled at each time step. The time weighting factor for the corresponding sampling point is calculated using the following logic: ,in, for The smooth displacement vector at time t. The normalized weighting coefficients are based on the time decay function and satisfy the following conditions: ; For the first The original displacement increment at each sampling time. This represents the total number of sampling points within the sliding window.

[0054] Based on this, the difference correction unit constructs the memory offset conversion logic, and the system monitors the frame rendering cycle of the graphics rendering pipeline in real time. The rendering offset latency asynchronous with the interactive input signal was calculated. To compensate for the modeling shape error caused by this latency, the system calculates a vertex attribute correction matrix related to rendering latency and translation vectors. This correction matrix applies to the vertex coordinates of the furniture mesh, synchronizing its offset to the rendering frame update time. The mesh update unit updates according to the calculated... The offset of the target sparse vertex array slice in video memory is calculated directly through the video memory image memory interface. Based on this offset address, the system executes targeted vertex attribute bit modification instructions instead of completely rewriting the scene mesh.

[0055] To address the performance bottleneck caused by high-frequency concurrent interactions, the system introduces synchronization state management logic based on grid index caching. When the interaction frequency is detected... Greater than 200Hz and memory update response time When the critical state exceeds 16ms, the mesh update unit automatically switches to instantiation update mode, which locks the preset basic mesh data of the repeating substructure and drives the redrawing of component positions only by updating the instance transformation parameter array. This eliminates the memory bus data congestion caused by frequent full updates. Furthermore, the above threshold parameters are determined offline based on the throughput limit of mainstream graphics processor buses and the graphics hardware environment of web pages. Among them, the 60Hz refresh rate threshold corresponds to the standard vertical synchronization refresh cycle of a conventional monitor, and interactive data below this frequency can be processed by the hardware pipeline in real time. The 200Hz interactive frequency threshold is the threshold for concurrent high sampling rate input devices. Under normal operating conditions, if the interaction frequency exceeds 200Hz and the memory update response latency exceeds 16ms, it indicates that the conventional full vertex recalculation has caused memory bus saturation and rendering pipeline blockage. The system can accurately capture the critical state of bus congestion and trigger instantiation updates by combining the above quantitative boundary conditions. In 100 consecutive interoperation load tests, the vertex coordinate position deviation of the system using this dynamic modeling strategy has always been maintained below 0.005mm, and the memory bus bandwidth utilization rate has been stable within 40% of the industry's conventional operating benchmark, ensuring the geometric continuity of furniture mesh updates and rendering pipeline throughput efficiency in high-frequency interaction scenarios.

[0056] Example 5: Before deploying the system for dynamic modeling of 3D home scenes, to ensure consistent modeling accuracy and response stability under different user terminal device hardware performance conditions, a standardized on-site calibration procedure was set up. The modeling system was started in the target operating environment, and the system automatically retrieved a set of pre-stored standard indoor benchmark floor plan data. This benchmark floor plan includes 100 controlled wall connection nodes and 10 furniture models of specific sizes. The system executed a pre-set benchmark modeling program, recording the real-time frame rate under specific display resolution and GPU load. Vertex buffer response time This is used as the initial environmental performance baseline for the current terminal environment. When the environmental performance baseline deviates from the preset modeling stability threshold, the system starts an automatic calibration program. By reading the remaining available bandwidth of the current video memory, the batch threshold of instantiation rendering is linearly adjusted to achieve a dynamic balance between modeling quality and system response speed.

[0057] During long-term system operation, to avoid the risks of historical data aging and cache overflow due to the accumulation of scene models, the system embeds a cache maintenance mechanism based on timeliness assurance and reconstruction. The system sets dynamic weights based on time decay for the mesh vertex index image interval sequence stored in the local cache. Its calculation formula is ,in, As the current time weight, This is the initial time weight value. The preset time decay factor, To account for the time difference of the last access to the data, whenever the cache space exceeds 85% of the capacity limit, the system starts an automatic cleanup procedure, prioritizing the deletion of data indexes with weights below the preset threshold to release video memory resources. When it is detected that key modeling parameters such as average vertex update latency have increased by more than 30% compared to the initial baseline, the system triggers a full reconstruction process, rereads the original floor plan file data and clears the existing vertex cache, and reconstructs the vertex attribute matrix using the updated geometric features to ensure that the system's modeling accuracy and rendering execution efficiency remain stable.

[0058] Example 6: Before the system is officially put into use, a standardized offline calibration process for dynamic modeling accuracy needs to be established to eliminate individual differences in floating-point computing power and graphics rendering pipeline latency among different hardware terminals. The calibration program calls the system's pre-set standard furniture geometry test package, which contains 100 wall nodes with preset coordinate attributes and 50 standard furniture geometry models. Each furniture model has initial bounding box parameters, including the reference dimensions of length, width, and height. Within the preset test environment, the system instructs the graphics processor to fully load the test package and dynamically simulate displacement calculations, recording the actual frame rendering time of the graphics pipeline within the preset update cycle. Time consumed by vertex attribute updates By establishing a linear regression model for two sets of data To determine the response benchmark of the computing system, where, Time spent updating vertex attributes For frame rendering time, A slope parameter that is positively correlated with the floating-point computing power of a graphics processor. The constant bias term for asynchronous scheduling in the graphics context is solved by the system through multiple iterative calculations. and The optimal value is obtained, and the linear regression model is stored in non-volatile memory as a time compensation benchmark for calculating the vertex matrix correction value in subsequent online dynamic modeling processes.

[0059] During dynamic modeling, to mitigate data jitter caused by real-time interactive input and ensure the geometric topological continuity of the mesh, the system employs a logical smoothing strategy based on adaptive temporal filtering. The system construction includes... A sliding sampling window of 10 data sample points performs filtering operations on the displacement input signal acquired in real time by the interactive device, and sets the smooth displacement vector as 1. Input displacement data is Its logical determination formula is as follows: ,in, for The smoothed output vector at time step, The variance of the data samples within the current sliding window The determined adaptive weighting coefficients satisfy... ; For the first The input displacement vector at each sampling time. The number of sample points in the window, when the system detects the variance of the input signal. When the preset mutation threshold is exceeded, the current sampling window will be automatically reset and... The numerical values ​​are adjusted to a preset minimum to shorten system response lag. Specifically, the adaptive weighting coefficients at each sampling time are determined by mapping the variance of all data samples within the current sliding window using an inverse proportional function. In interactive mode, the system calculates the displacement variance of historical sampling points within the current sliding window. The adaptive weighting coefficient assigned to a single sampling point is negatively correlated with the reciprocal of this variance. That is, when the variance index increases, indicating increased input trajectory jitter, the system reduces the weight contribution of high-frequency fluctuation terms in the final smooth output through this inverse proportional mapping, making the dynamic evolution of the smooth displacement vector more stable. Conversely, when the variance decreases and the input trajectory tends to be smoother, the system increases the weight allocation ratio of the corresponding sampling point. After the interaction ends, the system compares the spatial position of the current furniture vertex with the coordinates of the reference bounding box. The spatial residual is used to perform endpoint repositioning calibration on the vertex attribute array to ensure that the final geometric shape output by the dynamic modeling operation accurately fits the physical constraints of the scene.

[0060] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential characteristics of the present invention.

[0061] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention.

Claims

1. A dynamic modeling method for 3D home scenes, characterized in that, Includes the following steps: Step S1: Obtain real-time interactive displacement vector data representing the editing trajectory of the 3D scene; Step S2: When the capture frequency of real-time interactive displacement vector data exceeds the determined refresh rate threshold, the real-time interactive displacement vector data is cached in a circular temporary storage queue, and the weighted attenuation coefficient of each real-time interactive displacement vector data in the circular temporary storage queue is extracted and weighted summation is performed to merge it into a weighted hybrid deformation vector of spatial displacement dimension. Step S3: Calculate the local vertex attribute matrix correction value containing three-dimensional coordinate components, normal vector components, and texture coordinate components based on the weighted hybrid deformation vector, and calculate the temporal topology offset matrix according to the frame interval delay of the graphics context. Use the temporal topology offset matrix as an incremental matrix to perform intramatrix superposition transformation with the local vertex attribute matrix correction value to complete the temporal difference compensation correction. Step S4: Using the sparse vertex array slices stored in an interleaved structure, the local vertex attribute matrix correction values ​​after time difference compensation are passed as input arrays to the sub-buffer overwrite interface of the WebGL context. The target video memory buffer is addressed according to the determined starting byte offset to perform local in-situ overwrite, driving the graphics processor to reconstruct and update the deformed 3D model mesh topology using the target mesh vertex shader and the corresponding fragment shader.

2. The dynamic modeling method for 3D home scenes according to claim 1, characterized in that, Step S2 includes the following sub-steps: Step S21, within each time sliding window, assign a weighted attenuation coefficient that monotonically decreases with the advancement of the frame sequence time to each real-time interactive displacement vector data in the circular temporary queue; Step S22, obtain the topological displacement increment in each real-time interactive displacement vector data, and multiply the topological displacement increment with the corresponding weighted attenuation coefficient to generate multiple sets of weighted displacement matrices; Step S23, merge and accumulate the multiple sets of weighted displacement matrices in the spatial displacement dimension to form a weighted hybrid deformation vector.

3. The dynamic modeling method for 3D home scenes according to claim 1, characterized in that, Step S3 includes the following sub-steps: Step S31, obtain the frame interval time data between the current rendering frame and the adjacent previous frame; Step S32, calculate the asynchronous delay time for updating video memory data based on the frame interval time data, and establish a timing topology offset matrix based on the asynchronous delay time for updating video memory data.

4. The dynamic modeling method for 3D home scenes according to claim 1, characterized in that, It also includes the following steps: Step S5: When it is identified that the mesh topology change caused by the real-time interactive displacement vector data belongs to the local translation transformation of the preset repeating substructure in the scene, the static basic geometry mesh data stored in the video memory is locked, and the recalculation branch of the corresponding component mesh is closed; the updated local vertex attribute matrix correction value is directly written into the vertex shader attribute array of the graphics hardware as the instance transformation matrix, driving the graphics processor to complete the single-batch instantiation rendering update of the repeated substructure.

5. The dynamic modeling method for 3D home scenes according to claim 1, characterized in that, Step S4 includes the following sub-steps: Step S41, address the current video memory buffer through the binding of the WebGL context; Step S42, calculate the starting byte offset of the local vertex attribute matrix correction value in the video memory space arrangement; Step S43, pass the starting byte offset as the addressing reference to the sub-buffer overwrite interface, and overwrite the local vertex attribute matrix correction value containing the three-dimensional coordinate components, normal vector components and texture coordinate components.

6. The dynamic modeling method for 3D home scenes according to claim 4, characterized in that, It also includes the following steps: Step S6: Record the rate of change of the modulus of the weighted hybrid deformation vector within a continuous interaction cycle to generate a time-series evolution dataset; Step S7: Extract the decay features from the time-series evolution dataset and calculate the mesh convergence index; Step S8: When the mesh convergence index reaches a fixed stable threshold, slow down the overwrite frequency of the sub-buffer overwrite interface and update the global memory topology layout synchronously.

7. The dynamic modeling method for 3D home scenes according to claim 1, characterized in that, In a sparse vertex array slice stored in an interleaved structure, the attribute data of a single vertex is arranged continuously in the video memory space. The data arrangement order inside is that the three-dimensional coordinate components are adjacent to the normal vector components, and the normal vector components are adjacent to the texture coordinate components.

8. A dynamic modeling method for 3D home scenes according to claim 5, characterized in that, The starting byte offset calculated in step S42 has a spatial addressing step size equal to the total number of bytes of attribute data for a single vertex.

9. A dynamic modeling method for 3D home scenes according to claim 1, characterized in that, The data acquisition, temporary storage, matrix operation, and overwrite in steps S1 to S4 are completed by the web page graphics rendering engine driven by the script logic generated through compilation.

10. A dynamic modeling system for 3D home scenes, used to implement the dynamic modeling method for 3D home scenes as described in claim 1, characterized in that, include: The data acquisition unit is used to acquire real-time interactive displacement vector data that characterizes the editing trajectory of a 3D scene; The data fusion unit, coupled with the data acquisition unit, is used to cache the real-time interactive displacement vector data into a circular temporary storage queue when the acquisition frequency of the real-time interactive displacement vector data exceeds a certain refresh rate threshold. It also extracts the weighted attenuation coefficients of each real-time interactive displacement vector data in the circular temporary storage queue within the time sliding window, performs a weighted summation operation, and fuses them into a weighted hybrid deformation vector of spatial displacement dimension. The difference correction unit, coupled with the data fusion unit, is used to calculate the local vertex attribute matrix correction value containing three-dimensional coordinate components, normal vector components and texture coordinate components based on the weighted hybrid deformation vector, and to calculate the temporal topology offset matrix based on the frame interval delay of the graphics context. The temporal topology offset matrix is ​​used as the incremental matrix and the local vertex attribute matrix correction value is superimposed within the matrix to complete the temporal difference compensation correction. The mesh update unit, coupled with the difference correction unit, is used to slice the sparse vertex array stored in an interleaved structure. It takes the local vertex attribute matrix correction value after time-series difference compensation as the input array and passes it to the sub-buffer overwrite interface of the WebGL context. It addresses the target video memory buffer according to the determined starting byte offset and performs local in-situ overwrite. It drives the graphics processor to reconstruct the updated 3D model mesh topology using the target mesh vertex shader and the corresponding fragment shader.

Images