Finite element simulation data processing method and device for mixed reality

Abstract

The invention discloses a finite element simulation data processing method and equipment oriented to mixed reality, relates to the technical field of engineering simulation and mixed reality visualization, and aims to reduce the problems of large calculation load and lagging caused by rendering. The mixed reality-oriented finite element simulation data processing method comprises the following steps: acquiring analysis result data of a target model after finite element simulation calculation; combining a plurality of unit grids in the target model into at least one grid asset; performing high-precision coding on the original high-precision numerical value to obtain coded data; the coding data corresponding to the multiple engineering components are written into one or more texture coordinate channels of the grid assets, the grid assets are loaded in a three-dimensional rendering engine, the coding data in the texture coordinate channels are read through a self-defined shader, the coding data are decoded to recover high-precision numerical values, and the high-precision numerical values are obtained. And rendering the grid assets.

Description

Technical Field

[0001] This disclosure relates to the field of engineering simulation and mixed reality visualization technology, specifically to a finite element simulation data processing method and device for mixed reality. Background Technology

[0002] Mixed Reality (MR) technology, as an emerging technology in the field of physical and digital interaction, can combine the real and virtual worlds to create new environments and visualizations. It allows users to overlay digital models onto the real world at a 1:1 scale, enabling intuitive interaction between virtual information in the digital space and the real environment.

[0003] Finite element simulation, as a commonly used numerical simulation technique, has long been widely and deeply applied in the fields of civil engineering and intelligent construction.

[0004] In related technologies, finite element analysis software is typically used to create complex structural models containing a massive number of elements, and to perform simulation calculations on them for stress, strain, displacement, etc. In some scenarios, it is necessary to display the results of finite element simulation analysis in mixed reality. However, when displaying large and complex finite element models on mixed reality devices, it is difficult to achieve high fidelity and smooth operation due to rendering performance, data accuracy, and computational burden. Summary of the Invention

[0005] A first aspect of this disclosure provides a finite element simulation data processing method for mixed reality, the method comprising: The analysis results data of the target model after finite element simulation calculation are obtained; wherein, the analysis results data includes the original high-precision values ​​of each engineering component in the target model; Multiple cell grids in the target model are merged into at least one grid asset, wherein each cell grid represents one of the engineering components, and the number of grid assets is less than the number of cell grids; The original high-precision numerical value is encoded with high precision to obtain encoded data; The encoded data corresponding to each of the multiple engineering components is written into one or more texture coordinate channels of the mesh asset; The mesh asset is loaded into the 3D rendering engine, and the encoded data in the texture coordinate channel is read through a custom shader. The encoded data is then decoded to restore high-precision values ​​in order to render the mesh asset.

[0006] In an exemplary embodiment, the step of performing high-precision encoding on the original high-precision numerical value to obtain encoded data includes: The original high-precision value is normalized to obtain a normalized value; wherein the normalized value is a 32-bit floating-point number. The normalized numerical value is encoded into multiple data components; Among them, multiple data components serve as the encoded data.

[0007] In an exemplary embodiment, encoding the normalized numerical value into multiple data components includes: The normalized value is multiplied by a preset number of coding coefficients to obtain a number of coded values; Modulo operation on the plurality of encoded values Obtain the fractional part of the multiple encoded values; Based on the multiple encoded values ​​and the fractional part, multiple data components are obtained.

[0008] In an exemplary embodiment, obtaining multiple data components based on the multiple encoded values ​​and the fractional part includes: Precision correction is performed on multiple coded values ​​and their corresponding fractional parts to reduce the influence of lower bits on higher bits; The encoded values ​​obtained after precision correction are used as multiple data components.

[0009] In an exemplary embodiment, writing the encoded data corresponding to the plurality of engineering components into one or more texture coordinate channels of the mesh asset includes: The multiple data components are split and written into the corresponding components of one or more texture coordinate channels of the mesh asset; In addition, the texture coordinate channel is used as a data container so that the 3D rendering engine can call the data components from the texture coordinate channel.

[0010] In an exemplary embodiment, the method further includes: In response to a call to the target shader, the decoded data is rendered as a corresponding color in the mesh asset, the color representing the material of the mesh asset.

[0011] In an exemplary embodiment, the step of rendering the decoded data into a corresponding color in the mesh asset in response to a call to a target shader includes: The target shader is used to map the decoded high-precision numerical values ​​to corresponding color values. Output the color value to render a color cloud map on the mesh asset.

[0012] In an exemplary embodiment, after the method maps the decoded high-precision numerical values ​​to corresponding color values ​​in the mesh asset in response to a call to the target shader, the method further includes: Configure the Mixed Reality Development Kit in the 3D rendering engine; Package the mesh asset rendered with the aforementioned colors into an installation package; The installation package is deployed to a mixed reality device to enable the mixed reality display of the target model and the corresponding physical building on the mixed reality device.

[0013] In an exemplary embodiment, the encoded data includes multiple data components, and decoding the encoded data to recover a high-precision value includes: The multiple data components are multiplied by a preset decoding coefficient to obtain a normalized value; The normalized value is used as the high-precision value. The decoding coefficients correspond to the encoding coefficients used to encode the encoded data.

[0014] A second aspect of this disclosure provides a finite element simulation data processing device for mixed reality, comprising: The data acquisition module is used to acquire the analysis result data of the target model after finite element simulation calculation; wherein, the analysis result data includes the original high-precision values ​​of each engineering component in the target model; A mesh merging module is used to merge multiple unit meshes in the target model into at least one mesh asset, wherein each unit mesh represents one of the engineering components, and the number of mesh assets is less than the number of unit meshes; The encoding module is used to encode the original high-precision numerical value with high precision to obtain encoded data; The data writing module is used to write the encoded data corresponding to each of the multiple engineering components into one or more texture coordinate channels of the mesh asset; The decoding and rendering module loads the mesh asset in the 3D rendering engine, reads the encoded data in the texture coordinate channel through a custom shader, decodes the encoded data to recover high-precision values, and renders the mesh asset.

[0015] The finite element simulation data processing method for mixed reality adopted in this embodiment can acquire the analysis results data of the target model after finite element simulation calculation; and merge multiple unit meshes in the target model into at least one mesh asset. This merging of unit meshes significantly reduces the number of rendering calls required when rendering the target model, thus solving the rendering performance bottleneck caused by the complexity of the target model. Furthermore, the original high-precision values ​​can be encoded with high precision to obtain encoded data. This high-precision encoding preserves the accuracy of the original high-precision values, solving the technical challenge of high-fidelity rendering of large finite element simulation data on low-precision mobile platforms such as mixed reality devices. In subsequent rendering, targeted decoding is performed, effectively avoiding the color banding and data distortion problems caused by low-precision floating-point operations in traditional methods, ensuring the accuracy of the visualization results. Thus, by processing finite element simulation data, its display quality in mixed reality displays can be improved.

[0016] The above description is merely an overview of the technical solution disclosed herein. In order to better understand the technical means of this disclosure and to implement it in accordance with the contents of the specification, and to make the above and other objects, features and advantages of this disclosure more apparent and understandable, specific embodiments of this disclosure are described below. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments or related technologies of this disclosure, the accompanying drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the accompanying drawings described below are some embodiments of this disclosure. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. It should be noted that the scale in the drawings is for illustration only and does not represent the actual scale.

[0018] Figure 1 A flowchart illustrating the steps of a finite element simulation data processing method for mixed reality in one embodiment is shown. Figure 2 This is a schematic diagram of the interface of the finite element model created and the simulation results obtained after analysis in Midas Gen software. Figure 3 It is a schematic diagram of the final application scenario where the simulation results are aligned in situ on site and viewed. Figure 4 This is a schematic diagram of the cell mesh generated when exporting analysis structure data; Figure 5 This is a schematic diagram of the Material Inspector panel interface in the Unity engine. Figure 6This is a schematic diagram of the node graph of a custom shader in the Shader Graph editor; Figure 7 This is a screenshot of the build settings interface in the Unity engine, showing the configuration of the target platform (UWP) and architecture (ARM64); Figure 8 A schematic diagram of a simplified module of a finite element simulation data processing device for mixed reality is shown in one embodiment. Detailed Implementation

[0019] To make the above-mentioned objectives, features, and advantages of this disclosure more apparent and understandable, the technical solutions of the embodiments of this disclosure will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this disclosure. Based on the embodiments of this disclosure, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this disclosure.

[0020] In related technologies, importing and running professional, large-scale, and complex finite element models into a 3D rendering engine presents the following severe technical challenges: Challenge 1: Rendering performance bottleneck. This is because finite element models are typically composed of tens of thousands of independent element meshes. When these elements are imported as independent objects into 3D engines like Unity, a massive number of draw calls are generated. The central processing units of mobile devices, including 3D rendering engines, cannot handle such a high draw call burden, resulting in extremely low rendering frame rates and severe application stuttering.

[0021] Challenge 2 presents bottlenecks in data precision and computation. Traditional methods for real-time simulation display require processing the raw, high-precision numerical values ​​(e.g., 32-bit floating-point numbers) before passing them to the graphics processor (GPU). However, mobile GPUs, in order to optimize performance and power consumption, typically use low-precision (e.g., 16-bit half-precision) floating-point numbers for calculations or interpolation when processing data such as texture coordinates (UV). Directly storing normalized high-precision values ​​into the UV channels results in severe precision loss during GPU reading and processing, leading to color gradation, loss of detail, inability to achieve high-fidelity visualization, and even incorrect results. Furthermore, transmitting large amounts of raw data to the GPU for real-time color calculations exhausts the CPU's resources.

[0022] In view of this, embodiments of this disclosure provide a finite element simulation data processing method and apparatus for mixed reality. This finite element simulation data processing method for mixed reality can merge multiple unit meshes in a target model into at least one mesh asset to reduce the number of drawing calls generated during subsequent 3D rendering; and can perform high-precision encoding on the analysis result data of the target model after finite element simulation calculation to ensure the accuracy of the encoded data written into one or more texture coordinate channels of the mesh asset, thereby preserving the accuracy of the original high-precision values. This solves the technical problem of high-fidelity presentation of large finite element simulation data on low-precision mobile platforms such as mixed reality devices, and effectively avoids the problems of color banding and data distortion caused by low-precision floating-point operations in traditional methods.

[0023] The following description, in conjunction with the accompanying drawings, provides an exemplary account of the finite element simulation data processing method and apparatus for mixed reality according to embodiments of this disclosure.

[0024] First, please refer to Figure 1 As shown, Figure 1 A flowchart illustrating the steps of a finite element simulation data processing method for mixed reality in one embodiment is shown, as follows: Figure 1 As shown, the finite element simulation data processing method for mixed reality in this embodiment can be specifically applied to an electronic device, which may include a display screen. For example, the electronic device may be a personal computer. The electronic device may include a processor, such as a central processing unit and a graphics processing unit. The central processing unit and the graphics processing unit can be used to execute the finite element simulation data processing method for mixed reality.

[0025] like Figure 1 As shown, the specific steps include: Step S101: Obtain the analysis results data of the target model after finite element simulation calculation; The analysis results include the original high-precision values ​​of each engineering component in the target model.

[0026] In this embodiment, the target model can be a building model; for example, it can be such as... Figure 2 The architectural model shown.

[0027] The target model can include multiple cell grids, each cell grid corresponding to an engineering component. Generally speaking, a target model can include a large number of engineering components, and thus, a target model can include a large number of cell grids.

[0028] Among them, the target model can be used for finite element simulation calculation. Finite element analysis (FEA) technology is the core supporting technology for structural behavior simulation in civil engineering. It is mainly used for mechanical simulation and analysis of engineering structures and is an important means to determine whether an engineering structure is safe. Therefore, FEA data intuitively reflects the real-time mechanical state of the engineering structure and is an indispensable and important data component in engineering construction data management.

[0029] In this embodiment, the analysis result data may refer to the aforementioned FEA data, which includes the original high-precision values ​​of the engineering components.

[0030] For example, the original high-precision numerical library includes scalar values ​​such as stress, strain, and displacement of engineering components after simulation calculations.

[0031] In this embodiment, each engineering component in the target model has a corresponding original high-precision value for each of its grid vertices (i.e., unit mesh).

[0032] For example, when acquiring and analyzing structural data, a finite element model of the engineering component can be built and structural analysis performed in Midas Gen software to obtain simulation calculation results containing the original high-precision numerical values. Then, the geometric data of the target model can be exported as IFC (Industry Foundation Classes) format, and the IFC format file can be converted to Unity-recognizable FBX format using PixyzStudio software.

[0033] Among these methods, the data export function of Midas Gen software can be used to export the original scalar values ​​that correspond one-to-one with the mesh vertices of the unit mesh in the target model. Export as a text file, for example, as a .csv file.

[0034] Where i represents the i-th grid.

[0035] Step S102: Merge multiple cell meshes in the target model into at least one mesh asset; Each of the unit grids represents one of the engineering components, and the number of grid assets is less than the number of unit grids.

[0036] In this embodiment, multiple cell grids in the target model can be merged. For example, multiple cell grids can be merged into one grid, and the merged grid is called a grid asset.

[0037] In practice, multiple cell grids in the target model can be merged into a single independent grid, or multiple independent grids can be merged. However, the number of grid assets obtained after merging is less than the number of cell grids included in the target model.

[0038] For example, cell mesh merging can be performed in the Unity engine by running a C# script that calls Unity's Mesh.CombineMeshes API to merge multiple independent cell meshes into a new, single mesh object, thereby reducing the number of draw calls required during rendering.

[0039] In this example, the merging of cell meshes can be based on the geometric data obtained above. For example, the geometric data of cell meshes can be merged to generate a new, single geometric data. This is equivalent to creating a single mesh object. Thus, by merging the geometric data of cell meshes, the merging of mesh cells is achieved.

[0040] Thus, merging unit meshes can be understood as merging individual meshes at the same level. For example, if multiple unit meshes of the target model are parallel meshes, the geometric data of each unit mesh will be set to an independent file. Therefore, during the drawing process, each unit mesh will be treated as an independent mesh, generating a drawing call, resulting in a large number of drawing calls.

[0041] In this embodiment, multiple unit meshes can be viewed as a large, independent "unit mesh". In this way, the geometric data of multiple unit meshes will be collected into a single file. For example, multiple unit meshes as a whole correspond to only one file directory. Therefore, when calling, multiple unit meshes will be treated as a whole and called once, which greatly reduces the number of drawing calls. This allows the load generated by drawing calls to be handled by the central processing unit of the mobile device, thereby improving the rendering frame rate and avoiding application lag.

[0042] It is understandable that when merging multiple element meshes, the element meshes are not made to disappear, but rather their original shape and corresponding high-precision values ​​are preserved, so that merging does not change the finite element simulation results of the target model.

[0043] In one example of this embodiment, the process of merging cell meshes can be edited into code and written into an electronic device to perform the merging of cell meshes. The code may be as follows: / / 1. Get the MeshFilter component of all child objects MeshFilter[]meshFilters=rootModelObject.GetComponentsInChildren <meshfilter>( ); / / 2. Create a CombineInstance array CombineInstance[]combine =newCombineInstance[meshFilters.Length]; int i = 0; while(i <meshFilters.Length) { combinel[i].mesh =meshFilters[i].sharedMesh; combine[i].transform =meshFilters[i].transform.localToWorldMatrix ; i++; } / / 3. Create a new Mesh object and perform a merge. Mesh combinedMesh =new Mesh(); cmbinedMesh.CombineMeshes(combine, true, true); / / Core merging function / / 4. Assign the merged mesh to a new GameObject MeshFilter mf =optimizedobject.AddComponent <meshfilter>( ); mf.mesh = combinedMesh.

[0044] Step S103: Perform high-precision encoding on the original high-precision values ​​to obtain encoded data.

[0045] In this embodiment, the original high-precision numerical value can first be normalized to convert it into a value within a preset range of 0.0 to 1.0. This value can be a 32-bit floating-point number, thus ensuring the accuracy of the original high-precision numerical value. Next, the normalized value is encoded so that it can be converted into coded data composed of multiple data components, thereby realizing the encoding of the high-precision original high-precision numerical value into coded data with a relatively small data volume.

[0046] In this embodiment, compared to directly storing the normalized high-precision values ​​into the texture coordinate channel, by re-encoding the normalized values, the original precision can be maintained when the graphics processor reads and processes them, thus avoiding problems such as color layering and loss of detail.

[0047] In this embodiment, the original high-precision values ​​corresponding to multiple engineering components can be encoded in batches, for example, multiple original high-precision values ​​can be encoded in parallel.

[0048] Step S104: Write the encoded data corresponding to each of the multiple engineering components into one or more texture coordinate channels of the mesh asset.

[0049] Step S105: Load the mesh asset in the 3D rendering engine, and read the encoded data in the texture coordinate channel through a custom shader. Decode the encoded data to recover high-precision values ​​to render the mesh asset.

[0050] In this embodiment, the mesh asset in the target model is formed by merging multiple unit meshes. Thus, the mesh asset can include multiple unit meshes. Since each vertex of the unit mesh corresponds to a piece of encoded data, when writing the encoded data to one or more texture coordinate channels of the mesh asset, each piece of encoded data can be written to one or more texture coordinate channels of the corresponding vertex in the mesh asset according to the position of the vertex of the unit mesh corresponding to the encoded data.

[0051] In this embodiment, the texture coordinate channel can be understood as the "UV" channel of the mesh vertex. For example, the UV channel is a core concept in computer graphics, especially 3D modeling and rendering.

[0052] In one example of this embodiment, a unit mesh can correspond to one UV channel or multiple UV channels. When multiple UV channels are included, different UV channels are used to write the values ​​of different attributes in the encoded data. This allows the encoded data to be split and written into different texture coordinate channels, so that when rendering the mesh asset later, the unit mesh in the mesh asset can be wrapped with multi-dimensional textures.

[0053] In one example of this embodiment, when the encoded data corresponding to each of the multiple engineering components is obtained, the encoded data corresponding to each of the multiple engineering components can be written in batches into one or more texture coordinate channels of the mesh asset.

[0054] In this embodiment, the 3D rendering engine can be the Unity engine.

[0055] For example, a generated mesh asset whose UV channels (texture coordinate channels) already contain high-precision encoded data can be loaded into a Unity 3D rendering scene and a new material can be created for it.

[0056] Next, the encoded data is decoded using a configured custom shader to recover the original high-precision values. Then, the decoded high-precision values ​​are rendered into corresponding colors, thus rendering the mesh asset as a color cloud. The rendered color cloud can be referenced... Figure 3 As shown.

[0057] In some embodiments, when high-precision encoding is performed on the original high-precision numerical value to obtain encoded data, the original high-precision numerical value can be normalized to obtain a normalized numerical value; then, the normalized numerical value can be encoded into multiple data components; wherein, the normalized numerical value is a 32-bit floating-point number, and the multiple data components are used as encoded data.

[0058] In this embodiment, a C# script can be run to read the analysis result data in .csv format exported in the previous embodiment, and associate the original high-precision value v with the vertex index i of each cell mesh. raw,i Loaded into memory, thus allowing the processing of the raw, high-precision value v in memory. raw,i Normalization is performed.

[0059] As described in the previous embodiments, normalization is used to process the original high-precision numerical values ​​into values ​​of 0-1.

[0060] In this embodiment, the normalization process can be based on a preset global minimum value V. min and global maximum value V max Specifically, the normalized value of each original high-precision value can be calculated according to the following formula (1): Formula (1) In formula (1), V raw,i This is the original high-precision value.

[0061] The normalization process can be written as code and pre-stored in the electronic device.

[0062] For example, the code for the overall coding process is shown below: / / Assuming this is a function snippet that processes data from a single vertex. void ProcessSingleVertexData(float rawValue, float minValue, floatmaxValue, List <vector4> / / (corresponding to normalization processing) float normalizedValue =0f; if (maxValue>minValue) { / / formula: v_norm=clamp((v_raw-v_min) / (v_max -v_min),0.0,1.0) NormalizedValue =Mathf.Clamp01((rawValue -minValue) / (maxValue -minValue)); } / / (corresponding to call high-precision encoding function) Vector4 encodedValue =EncodefloatRGBA (normalizedValue); / / (corresponding to store the encoding result in the list-show data flow) uvDataList.Add(encodedValue)。

[0063] Among them, the meaning of vDataList.Add(encodedValue) is to write the multiple data components obtained by final encoding to the uvDataList list.

[0064] Among them, encodedValue represents the encoded data.

[0065] After the original high-precision value is normalized according to the above process, the normalized value of each original high-precision value can be obtained. Among them, the normalized value can be encoded into multiple data components to ensure the data precision of the original high-precision value in the encoding process.

[0066] In this embodiment, the multiple data components can be understood as converting the normalized value to adapt to the value range of the texture coordinate channel. For example, the value range of the texture coordinate channel is 0-255. Since the normalized value contains floating-point numbers, the converted value includes integer values and decimal values. The data classification can be understood as multiple data components obtained by performing corresponding mathematical calculations on the integer values and decimal values in the conversion, and each data component belongs to part of the converted value.

[0067] In one example of the embodiment, when the normalized value is encoded into a plurality of data components, the normalized value can be multiplied by a plurality of preset encoding coefficients to obtain a plurality of encoding values; then, the plurality of encoding values are subjected to a modulo operation to obtain decimal parts of the plurality of encoding values; and based on the plurality of encoding values and the decimal parts, the plurality of data components are obtained.

[0068] In the example, the normalized value v of each original high-precision value can be obtained by using the above code (written as a C# script). norm,i Then, a high-precision encoding operation is performed on the normalized value.

[0069] In the high-precision encoding operation, a plurality of preset encoding coefficients can be multiplied by the normalized value to obtain a plurality of encoding values. The plurality of encoding values can be understood as a plurality of components obtained by encoding the normalized value.

[0070] For example, the plurality of preset encoding coefficients can include 1, 255, 255 2 , 255 3 and the like. Each encoding coefficient is multiplied by the normalized value to obtain an encoding value corresponding to each encoding coefficient.

[0071] In the example, a decimal bit offset can be defined in advance, and the obtained encoding value can be subjected to a modulo operation.

[0072] For example, in the script program, the decimal part of each encoding value can be obtained by using the modulo operation %1.0f, and thus the decimal part of each component can be obtained.

[0073] In the example, f represents a float or double type floating point number.

[0074] In one example of the embodiment, when the plurality of data components are obtained based on the plurality of encoding values and the decimal parts of the components, precision correction can be performed on the encoding values and the decimal parts of the components to reduce the influence of low bits on high bits; and the four-component vector obtained after the precision correction is taken as the plurality of data components.

[0075] In the example, the process of performing the precision correction can be that the encoding values are subjected to the precision correction based on the decimal parts corresponding to the encoding values.

[0076] For example, the precision correction can be corrected by using the rounding method to reduce the influence of low bits on high bits, and the final encoding value can be obtained after the correction.

[0077] In the example, the plurality of encoding values obtained after the precision correction can be taken as the plurality of data components.

[0078] As described in the foregoing embodiment, the encoding process can be written as code and pre-burned into the central processor CPU of the electronic device, so that the central processor can read the original high-precision value from the memory and then perform the encoding process on the original high-precision value.

[0079] Exemplarily, the code of the encoding process is as follows: / / ---High-precision encoding function EncodefloatRGBA--- Vector4 EncodefloatRGBA(float v) { / / Ensure that v is in the interval [0, 1] v = Mathf.Clamp01(v); / / Encoding coefficient Vector4 kEncodeMul = new Vector4(1.0f, 255.0f, 65025.0f, 16581375.0f); / / Encoding decimal bit offset float kEncodeBit = 1.0f / 255.0f; Vector4 enc = kEncodeMul * v; / / Take the fractional part frc(x) = x-floor(x) -> C# use %1.0f to realize enc = new Vector4(enc.x % 1.0f, enc.y % 1.0f, enc.z % 1.0f, enc.w % 1.0f); / / Precision correction (subtract the influence of low bits on high bits) enc.X -= enc.y * kEncodeBit; enc.y -= enc.z * kEncodeBit; enc.z -= enc.w * kEncodeBit; return enc; / / Return Vector4 containing encoded data } In the foregoing code, Vector4 EncodefloatRGBA(float v) represents encoding the original high-precision value V into 4 data components.

[0080] In the foregoing code, float kEncodeBit = 1.0f / 255.0f represents defining the bit offset coefficient.

[0081] In this embodiment, after the encoding is completed, a C# script can be run to add the encoded multiple data components to a list, for example, to uvDataList.

[0082] In the encoding manner of this embodiment, since the 32-bit floating point number of the original high-precision value is retained after the normalization processing of the original high-precision value, the accuracy of the value can be improved when the multiple encoded values are obtained, and the accuracy of the encoded values can be corrected by using the decimal place offset, so that the accuracy of the obtained multiple data components is higher. Thus, when subsequent rendering is performed, the color information will not be lost, so that the accuracy of the rendering can be improved.

[0083] In some embodiments, when the encoded data corresponding to the multiple engineering components is written into one or more texture coordinate channels of the mesh asset, the multiple data components can be split and written into corresponding components of the one or more texture coordinate channels of the mesh asset; and the texture coordinate channel is used as a data container to enable the three-dimensional rendering engine to call the data components from the texture coordinate channel.

[0084] In this embodiment, since the original high-precision value at the vertex of each unit mesh is encoded into multiple data components, different data components are obtained based on different encoding coefficients, so different data components can be written into different vectors of the texture coordinate channel.

[0085] Among them, one UV channel (such as uv3) can store 4-dimensional data (float4 / Vector4), and the thinking data can correspond to the four RGBA vectors of the UV channel respectively; for example, if four data components are included, the four data components can be written into the RGBA four vectors of the UV channel, thereby improving the accuracy of the texture wrapping of the unit mesh.

[0086] Among them, the encoding data used to identify different attributes of the mesh can be stored in different UV channels, for example, the encoding data includes encoding data A identifying the stress attribute of the mesh, encoding data B identifying the strain attribute of the mesh, and encoding data C identifying the displacement attribute of the mesh, then the encoding data A can be stored in UV2, the encoding data B is stored in UV3, and the encoding data C can be stored in UV4.

[0087] As in the foregoing embodiment, the plurality of data components encoding each unit mesh are written into uvDataList, in this example, a method of setting UV data of the mesh object can be called, such as Mesh.SetUVs(channelIndex, uvDataList), to batch write the data of the entire uvDataList list into one or more texture coordinate channels of the mesh asset that are not commonly used, for example, it can be written into a texture coordinate channel, such as channelIndex = 2 corresponds to the uv3 channel. Or, it can be written into multiple texture coordinate channels, such as uv2~uv4 channels.

[0088] In this embodiment, the UV channel can be regarded as a container of high-precision encoded data (i.e., a plurality of data components).

[0089] Thus, when the three-dimensional rendering engine renders, the data components can be called from the texture coordinate channel, and the mesh asset is rendered based on the data components.

[0090] In some embodiments, after writing the encoded data to the mesh asset, the mesh asset with the written encoded data can be rendered. Specifically, the encoded data can be decoded by a target shader to obtain high-precision numerical values, and then the high-precision numerical values are rendered as corresponding colors in the mesh asset by the target shader.

[0091] In this embodiment, the color can represent the material of the mesh asset. The material is an attribute of the mesh asset, which can represent the material of the engineering member.

[0092] For example, the generated mesh asset whose UV channel contains high-precision encoded data can be loaded into a three-dimensional rendering scene of Unity, and a new material can be created for it.

[0093] For example, a "UV" node can be created, and the channel is set to the channel where the high-precision encoded data is written, to read the encoded plurality of data components stored in the UV channel.

[0094] Then, a target shader can be specified for the material of the mesh asset, which is a custom shader created by ShaderGraph to configure a custom rendering effect.

[0095] In this embodiment, the target shader can be used to decode the encoded data in reverse of the encoding process, thereby obtaining high-precision numerical values.

[0096] In this embodiment, the target shader can be located in a graphics processing unit (GPU).

[0097] In one example of the present embodiment, in response to a call of the target shader, the high-precision numerical values are rendered as corresponding color values in the mesh asset by the target shader. Step S1: mapping the decoded high-precision numerical values to corresponding color values by the target shader Step S2: outputting the color values to render a color cloud on the mesh asset.

[0098] In the present example, the decoding process of the encoded data can be the inverse of the encoding process in the foregoing embodiment.

[0099] Illustratively, in Step S2, the plurality of data components can be multiplied by preset decoding coefficients to obtain normalized numerical values during decoding; the normalized numerical values can be used as high-precision numerical values, wherein the decoding coefficients correspond to the encoding coefficients used to encode the encoded data.

[0100] For example, a node combination for performing the decoding operation can be created, such as a "Vector 4” node for storing the decoding coefficients, which can be , and a "Dot Product” node for multiplying each data component read by the corresponding decoding coefficient.

[0101] The dot product operation can be a reorganization process inverse to the encoding operation, by which the data components can be restored to normalized numerical values . Accordingly, in Step S2, the normalized numerical values can be mapped to corresponding color values by the target shader.

[0102] In the present embodiment, a "Texture 2D Asset” attribute node ColorRampTex and a "SampleTexture 2D” node can be created. The ColorRampTex is used to specify a color legend texture, and the normalized numerical values decoded in Step S2 are used as U coordinates and the constant 0.5 is used as a V coordinate to sample the ColorRampTex texture, so as to map the normalized numerical values to corresponding color values according to the decoded normalized numerical values and in reference to the preset color legend .

[0103] In the present embodiment, the calculated color values are connected to the "Base Color” input port of the main node, so as to render a high-fidelity color cloud on the mesh asset.

[0104] It should be noted that steps S1-S4 of the embodiment can be executed by a graphics processor in the electronic device, so that the central processing unit CPU can be avoided from performing a large amount of calculation at runtime, the data calculation bottleneck is solved, and the high frame rate smooth running of the application is ensured.

[0105] In some embodiments, after the encoded data is rendered as corresponding colors in the mesh asset by the target shader in response to the call of the target shader, the mesh asset can also be displayed in mixed reality. Specifically, a mixed reality development kit can be configured in the three-dimensional rendering engine; the mesh asset rendered with colors is packaged as an installation package; and the installation package is deployed to a mixed reality device to realize the mixed reality display of the target model and the entity building corresponding to the target model on the mixed reality device.

[0106] Illustratively, when the mixed reality development kit is configured in the three-dimensional rendering engine, taking the three-dimensional rendering engine Unity as an example, the Microsoft MRTK kit can be imported into Unity, which is completed by the PackageManager of Unity. After importing, the core prefabs of MRTK are automatically added to the current scene and the default mixed reality configuration file (Configuration ProFile) is set by Mixed Reality > MRTK > Add to Scene and Configure... in the top menu bar of Unity.

[0107] Wherein, when the mesh asset rendered with colors is packaged as an installation package, the File>Build Settings... window can be opened in Unity. In the platform list, select "Universal Windows Platform" and click "Switch Platform" button to switch the project build target to UWP. Then, in the "Build Settings" window, configure the specific parameters of UWP, set "Architecture" to "ARM64"; set "Build Type" to "D3DProject". After the configuration is completed, click "Build" button, Unity will generate a folder containing Visual Studio solution (.sln file). Then, In the.sln solution file generated in Visual Studio, set the solution configuration (Solution Configuration) to "Release" and the solution platform (Solution Platform) to "ARM64" in the top toolbar of Visual Studio, and publish the installation package.

[0108] The installation package is an installation package of the mesh asset.

[0109] When the installation package is deployed on the mixed reality device, the ARM64 format installation package can be deployed on the Hololens2 through the Wi-Fi connection of the Hololens2, so as to complete the deployment of the installation package on the mixed reality device.

[0110] After that, the mesh asset rendered with color can be displayed on the real building corresponding to the target model on the mixed reality device. For example, as shown in Figure 3 , Figure 3 the final application scene diagram in the field in-situ alignment and viewing the simulation results is shown, Figure 3 different colors in the figure represent different materials of the grid unit, which are related to the data components obtained by coding.

[0111] Next, the finite element simulation data processing method for mixed reality of the embodiment will be described as an example: Step 1: Obtain the geometric data and analysis result data of the target model after completing the finite element simulation calculation on the desktop; wherein the analysis result data includes the original high-precision numerical value of each engineering component in the target model.

[0112] Further, step 1 is executed in MidasGen, including the following steps: Step 1.1: As shown in Figure 2 , a finite element model of the engineering component is established in the Midas Gen software and a structural analysis is performed to obtain analysis result data containing original high-precision numerical values, including stress, strain, displacement and other scalar values.

[0113] Step 1.2: As shown in Figure 4 , the geometric data of the target model in step 1.1 is exported in IFC format, and the IFC format file is converted to FBX format recognizable by Unity through Pixyz Studio software.

[0114] Step 1.3: Use the data export function of the Midas Gen software to export the original high-precision numerical values corresponding to the model grid vertices obtained in step 1.1 to a text file, such as a.csv format.

[0115] Step 2: Merge multiple unit grids of the target model into one or more mesh assets to optimize rendering performance.

[0116] For example, this can be achieved by running a C# script within the Unity engine to optimize the rendering performance of the target model. Specifically, the C# script merges multiple independent cell meshes of the model exported in step 1.2 into a single or a few mesh assets. Specifically, the script calls Unity's Mesh.CombineMeshes API to merge the independent mesh data into a new, single mesh object, thereby achieving the goal of merging cell meshes and reducing the draw calls required for rendering on mixed reality devices.

[0117] Step 3: Encode the original high-precision values ​​corresponding to the vertices of the unit mesh in the analysis result data, and store the encoded data into one or more texture coordinate channels of the merged mesh; Furthermore, step 3 is executed within the Unity engine by running a C# script, including the following steps: Step 3.1: Run the C# script to read the text file (.csv) exported in Step 1.3 and match it with each vertex index. Related raw high-precision values Load into memory. Then, for each original high-precision value... Perform linear normalization and map it to the standard Within the interval, normalized values ​​are obtained. The normalization calculation is based on a preset global minimum value. and global maximum value The calculation formula is as shown in equation (1). Step 3.2: The C# script processes each normalized value obtained in Step 3.1. (Typically a 32-bit floating-point number) Perform high-precision encoding operations. The specific high-precision encoding function can be found in the code of the aforementioned embodiment. Specifically, it receives a floating-point number v in the range of 0 to 1 as input, first ensuring the input value is valid using Mathf.Clamp01; then it defines the encoding coefficients kEncodeMul (containing...). ) and decimal offset kEncodeBit ( Next, the input value v is multiplied by the encoding coefficient to obtain multiple encoded values ​​enc; then, a modulo operation is performed. Obtain the fractional part of multiple encoded values; finally, perform a precision correction step (subtract the influence of the low bits on the high bits) and return the final encoded values ​​(Vector4) encodedValue.

[0118] Step 3.3: Run the C# script and convert the Vector4 encodedValue from Step 3.2 into a variable, such as... Figure 5 As shown on the left, add the data to a list called uvDataList. After processing all vertices, call the mesh object's setUV data method (such as Mesh.SetUVs(channelIndex, uvDataList)) to write the data of the entire list in batches to one or more unused texture coordinate channels of the merged mesh in step 2. For example, channelIndex = 2 corresponds to the uv3 channel.

[0119] This step uses the UV channel as a container for high-precision encoded data.

[0120] Step 4: Load the mesh assets in the 3D rendering engine and configure a custom rendering that includes data decoding operations; Furthermore, step 4 involves loading and rendering the optimized mesh assets generated in step 3, including the following steps: Step 4.1: Load the mesh asset generated in Step 3, whose UV channels already contain high-precision encoded data, into the Unity scene and create a new material for it.

[0121] Step 4.2: As Figure 5 As shown, a custom shader created via Shader Graph is specified for the material of the mesh asset to configure custom rendering effects.

[0122] Furthermore, such as Figure 6 As shown, its core node logic is constructed as follows: Step 4.2.1: Create a "UV" node and set the channel to the channel through which the data was written in Step 3.3, so as to read the encoded Vector4 encodedValue stored in the UV channel.

[0123] Step 4.2.2: Create a node combination to perform the decoding operation. A "Vector 4" node can be created to store the decoding coefficients (e.g., ...). Then, a "Dot Product" node is created, and each read data component's encodedValue is multiplied by the decoded coefficient. This multiplication operation performs a reassembly process that is the reverse of the encoding operation in step 3.2. The output is the normalized value with restored precision.

[0124] Step 4.2.3: Create the "Texture 2D Asset" attribute node ColorRampTex (to specify the color legend texture) and the "Sample Texture 2D" node. Then, decode the normalized values ​​obtained from the previous step. Using the U coordinate as the U coordinate and the constant 0.5 as the V coordinate, the ColorRampTex texture is sampled. Based on the decoded normalized values ​​and referring to a preset color legend, it is then mapped to the corresponding color values. .

[0125] Step 4.2.4: Calculate the color values It connects to the "Base Color" input port of the master node to render a high-fidelity color cloud map on the model mesh.

[0126] Step 5: Package the project as a mixed reality application and deploy it to a mixed reality device.

[0127] In step 5, perform the following steps in Unity: Step 5.1: Import the Microsoft MRTK toolkit into Unity. This is done through Unity's PackageManager. After importing, the core MRTK prefabs will be automatically added to the current scene via Mixed Reality > MRTK > Add to Scene and Configure... in Unity's top menu bar, and the default Mixed Reality configuration profile will be set.

[0128] Step 5.2: As Figure 7 As shown, open the File > Build Settings... window in Unity. In the platform list, select "Universal Windows Platform" and click the "Switch Platform" button to switch the project build target to UWP.

[0129] Step 5.3: In the "Build Settings" window, configure the specific parameters for UWP. Set "Architecture" to "ARM64" and "Build Type" to "D3DProject". After configuration, click the "Build" button, and Unity will generate a folder containing the Visual Studio solution (.sln file).

[0130] Step 5.4: Open the .sln solution file generated in Step 5.3 in Visual Studio. In the top toolbar of Visual Studio, set the Solution Configuration to "Release" and the Solution Platform to "ARM64", and publish the installation package. Finally, connect to the HoloLens2 device via Wi-Fi and deploy the ARM64 format installation package to the HoloLens2.

[0131] The finite element simulation data processing method for mixed reality adopted in the above embodiments has the following advantages and positive effects: ① By merging multiple independent unit meshes of the target model into a single mesh asset, the number of rendering calls required for rendering is significantly reduced, thus solving the rendering performance bottleneck caused by the complexity of the target model.

[0132] ② By using an "encoding-decoding" mechanism, the technical challenge of high-fidelity presentation of large-scale FEA simulation data on low-precision mobile platforms such as mixed reality devices is solved. This effectively avoids color banding and data distortion caused by low-precision floating-point operations of graphics processors in related technologies, ensuring the accuracy of visualization results.

[0133] ③ By placing the color cloud image calculation task entirely on the graphics processing unit (GPU), the CPU is spared from performing a large amount of calculations during runtime, thus solving the data calculation bottleneck and ensuring smooth operation of the application at a high frame rate.

[0134] ④ The encoding, decoding, and rendering methods are not only applicable to structural mechanics simulation, but can also be extended to other fields such as fluid mechanics, thermodynamics, and geological disaster simulation that rely on high-precision scalar field data for visualization on mobile devices.

[0135] ⑤ It enables smooth, in-situ, full-size, and high-fidelity visualization of desktop simulation results in real engineering scenarios, solving the practical problem that traditional finite element simulation is detached from the real site and difficult to perform in-situ analysis.

[0136] Based on the same inventive concept, this disclosure also provides a finite element simulation data processing device for mixed reality. Please refer to... Figure 8 As shown, the finite element simulation data processing equipment includes the following modules: The data acquisition module is used to acquire the analysis result data of the target model after finite element simulation calculation; wherein, the analysis result data includes the original high-precision values ​​of each engineering component in the target model; A mesh merging module is used to merge multiple unit meshes in the target model into at least one mesh asset, wherein each unit mesh represents one of the engineering components, and the number of mesh assets is less than the number of unit meshes; The encoding module is used to encode the original high-precision numerical value with high precision to obtain encoded data; The data writing module is used to write the encoded data corresponding to each of the multiple engineering components into one or more texture coordinate channels of the mesh asset; The decoding and rendering module loads the mesh asset in the 3D rendering engine, reads the encoded data in the texture coordinate channel through a custom shader, decodes the encoded data to recover high-precision values, and renders the mesh asset.

[0137] In some embodiments, the encoding module includes the following units: A normalization unit is used to normalize the original high-precision value to obtain a normalized value; wherein the normalized value is a 32-bit floating-point number. An encoding unit is used to encode the normalized numerical value into multiple data components; Among them, multiple data components serve as the encoded data.

[0138] In some embodiments, the normalization unit includes: The multiplication unit is used to multiply the normalized value by a preset number of coding coefficients to obtain a number of coded values; Modulo operation unit, used for performing modulo operation on the plurality of encoded values. Obtain the fractional part of the plurality of encoded values; and, based on the plurality of encoded values ​​and the fractional part, obtain a plurality of data components.

[0139] In some embodiments, the modulo operation unit includes: The correction subunit is configured to perform precision correction on the plurality of coded values ​​and the fractional part corresponding to the coded values ​​to reduce the influence of the low bits on the high bits; and to use the coded values ​​obtained after precision correction as the plurality of data components.

[0140] In some embodiments, the data writing module is configured to split and write the plurality of data components into corresponding components of one or more texture coordinate channels of the mesh asset; and to use the texture coordinate channels as data containers so that the 3D rendering engine can call the data components from the texture coordinate channels.

[0141] In some embodiments, the device further includes: A shading module is used to respond to a call to the target shader and render the decoded data into a corresponding color in the mesh asset, wherein the color represents the material of the mesh asset.

[0142] In some embodiments, the coloring module includes: The color mapping unit is used to map the decoded high-precision numerical value to the corresponding color value using the target shader; A color output unit is used to output the color value to render a color cloud map on the mesh asset.

[0143] In some embodiments, the device further includes: Configuration unit, used to configure the Mixed Reality Development Kit in the 3D rendering engine; A packaging unit is used to package the mesh asset rendered with the color into an installation package; The deployment unit is used to deploy the installation package to a mixed reality device to realize the mixed reality display of the target model and the corresponding physical building on the mixed reality device.

[0144] In some embodiments, the encoded data includes multiple data components, and the decoding and rendering module is specifically used to perform a dot product operation on the multiple data components with preset decoding coefficients to obtain the normalized value; wherein, the normalized value is used as the high-precision value, and the decoding coefficients correspond to the encoding coefficients of the encoded data.

[0145] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.

[0146] Finally, 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.

[0147] The foregoing has provided a detailed description of a finite element simulation data processing method and device for mixed reality provided by this disclosure. Specific examples have been used to illustrate the principles and implementation methods of this disclosure. The descriptions of the above embodiments are only for the purpose of helping to understand the method and core ideas of this disclosure. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this disclosure. Therefore, the content of this specification should not be construed as a limitation of this disclosure.

[0148] Other embodiments of this disclosure will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This disclosure is intended to cover any variations, uses, or adaptations of this disclosure that follow the general principles of this disclosure and include common knowledge or customary techniques in the art not disclosed herein. The specification and examples are to be considered exemplary only, and the true scope and spirit of this disclosure are indicated by the following claims.

[0149] It should be understood that this disclosure is not limited to the precise structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this disclosure is limited only by the appended claims.

[0150] The terms "one embodiment," "embodiment," or "one or more embodiments" as used herein mean that a particular feature, structure, or characteristic described in connection with an embodiment is included in at least one embodiment of this disclosure. Furthermore, please note that the examples of the phrase "in one embodiment" do not necessarily all refer to the same embodiment.

[0151] Numerous specific details are set forth in the specification provided herein. However, it will be understood that embodiments of this disclosure may be practiced without these specific details. In some instances, well-known methods, structures, and techniques have not been shown in detail so as not to obscure the understanding of this specification.

[0152] In the claims, any reference signs placed between parentheses should not be construed as limiting the claims. The word "comprising" does not exclude the presence of elements or steps not listed in the claims. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. This disclosure can be implemented by means of hardware comprising a plurality of different elements and by means of a suitably programmed computer. In a unit claim enumerating a plurality of means, several of these means may be embodied by the same item of hardware. The use of the words first, second, and third, etc., does not indicate any order. These words may be interpreted as names.

[0153] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this disclosure, and are not intended to limit them. Although this disclosure has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this disclosure. < / meshfilter> < / meshfilter>

Claims

1. A finite element simulation data processing method for mixed reality, characterized in that, The method includes: The analysis results data of the target model after finite element simulation calculation are obtained; wherein, the analysis results data includes the original high-precision values ​​of each engineering component in the target model; Multiple cell grids in the target model are merged into at least one grid asset, wherein each cell grid represents one of the engineering components, and the number of grid assets is less than the number of cell grids; The original high-precision numerical value is encoded with high precision to obtain encoded data; The encoded data corresponding to each of the multiple engineering components is written into one or more texture coordinate channels of the mesh asset; The mesh asset is loaded into the 3D rendering engine, and the encoded data in the texture coordinate channel is read through a custom shader. The encoded data is then decoded to restore high-precision values ​​in order to render the mesh asset.

2. The finite element simulation data processing method for mixed reality according to claim 1, characterized in that, The process of performing high-precision encoding on the original high-precision numerical value to obtain encoded data includes: The original high-precision value is normalized to obtain a normalized value; wherein the normalized value is a 32-bit floating-point number. The normalized numerical value is encoded into multiple data components; Among them, multiple data components serve as the encoded data.

3. The finite element simulation data processing method for mixed reality according to claim 2, characterized in that, Encoding the normalized numerical value into multiple data components includes: The normalized value is multiplied by a preset number of coding coefficients to obtain a number of coded values; Modulo operation on the plurality of encoded values Obtain the fractional part of the multiple encoded values; Based on the multiple encoded values ​​and the fractional part, multiple data components are obtained.

4. The finite element simulation data processing method for mixed reality according to claim 3, characterized in that, The step of obtaining multiple data components based on the multiple encoded values ​​and the fractional part includes: Precision correction is performed on multiple coded values ​​and their corresponding fractional parts to reduce the influence of lower bits on higher bits; The encoded values ​​obtained after precision correction are used as multiple data components.

5. The finite element simulation data processing method for mixed reality according to claim 1, characterized in that, The step of writing the encoded data corresponding to the multiple engineering components into one or more texture coordinate channels of the mesh asset includes: The multiple data components are split and written into corresponding components of one or more texture coordinate channels of the mesh asset; and, The texture coordinate channel is used as a data container so that the 3D rendering engine can call the data components from the texture coordinate channel.

6. The finite element simulation data processing method for mixed reality according to claim 1, characterized in that, The method further includes: In response to a call to the target shader, the decoded data is rendered as a corresponding color in the mesh asset, the color representing the material of the mesh asset.

7. The finite element simulation data processing method for mixed reality according to claim 6, characterized in that, The step of responding to a call to a target shader, and rendering the decoded data as a corresponding color in the mesh asset via the target shader, includes: The target shader is used to map the decoded high-precision numerical values ​​to corresponding color values. Output the color value to render a color cloud map on the mesh asset.

8. The finite element simulation data processing method for mixed reality according to claim 6, characterized in that, After responding to a call to the target shader and mapping the decoded high-precision numerical values ​​to corresponding color values ​​in the mesh asset via the target shader, the method further includes: Configure the Mixed Reality Development Kit in the 3D rendering engine; Package the mesh asset rendered with the aforementioned colors into an installation package; The installation package is deployed to a mixed reality device to enable the mixed reality display of the target model and the corresponding physical building on the mixed reality device.

9. The finite element simulation data processing method for mixed reality according to claim 1, characterized in that, The encoded data includes multiple data components, and decoding the encoded data to recover high-precision values ​​includes: The multiple data components are multiplied by a preset decoding coefficient to obtain a normalized value; The normalized value is used as the high-precision value. The decoding coefficients correspond to the encoding coefficients used to encode the encoded data.

10. A finite element simulation data processing device for mixed reality, characterized in that, include: The data acquisition module is used to acquire the analysis result data of the target model after finite element simulation calculation; wherein, the analysis result data includes the original high-precision values ​​of each engineering component in the target model; A mesh merging module is used to merge multiple unit meshes in the target model into at least one mesh asset, wherein each unit mesh represents one of the engineering components, and the number of mesh assets is less than the number of unit meshes; The encoding module is used to encode the original high-precision numerical value with high precision to obtain encoded data; The data writing module is used to write the encoded data corresponding to each of the multiple engineering components into one or more texture coordinate channels of the mesh asset; The decoding and rendering module loads the mesh asset in the 3D rendering engine, reads the encoded data in the texture coordinate channel through a custom shader, decodes the encoded data to recover high-precision values, and renders the mesh asset.

Images