A lightweight cae geometry engine and cloud real-time collaboration method and system

Abstract

The application relates to the technical field of CAE preprocessing and cloud cooperation, and discloses a lightweight CAE geometry engine and a cloud real-time cooperation method and system. A cloud server acquires an original CAE geometry model, performs topological simplification and data compression on the original CAE geometry model, and generates a lightweight geometry data file containing multiple resolution levels; the cloud server pushes the received difference data packet to other online cooperation terminals; the other cooperation terminals parse the unique version number carried by the difference data packet through a locally loaded WebAssembly geometry engine module, and perform operation replay updating on the local geometry model according to the differential data contained in the difference data packet. According to the scheme, the original CAE model data volume is reduced by 90%-95%, the WebAssembly engine realizes a 100,000-face model rendering frame rate of 30-60 fps, and the operation response delay is less than or equal to 100 ms, thereby breaking through the performance bottleneck of browser-side geometry processing.

Description

Technical Field

[0001] This invention relates to the fields of CAE preprocessing and cloud collaboration technology, and in particular to a lightweight CAE geometry engine and a cloud real-time collaboration method and system. Background Technology

[0002] In CAE preprocessing workflows, multi-team collaboration in different locations (such as joint modeling between OEMs and suppliers, and cross-regional cooperation between design and simulation teams) is a common requirement, but existing technologies have three major pain points: Local software dependency and low collaboration efficiency: Traditional CAE preprocessing relies on local heavy software such as ANSYS and HyperMesh. During collaboration, complete geometric models need to be transferred repeatedly, which consumes a lot of bandwidth and is prone to confusion during version iteration. Web-based geometry processing capabilities are weak: Existing WebCAE tools (such as lightweight model viewers) only support static model browsing and cannot perform interactive operations such as geometry simplification and precise annotation; moreover, the rendering efficiency based on JavaScript is low, with a frame rate of <15fps when loading a 100,000-face model, resulting in noticeable lag. Poor real-time collaboration synchronization: Existing web collaboration tools only support text / image comments and cannot be associated with geometric model coordinates; moreover, modification synchronization depends on the full model retransmission, and the non-real-time nature causes collaboration delays.

[0003] Existing technologies cannot meet the cloud collaboration requirements of "lightweight, real-time, and accurate" CAE preprocessing, and there is an urgent need for a high-efficiency geometry engine and differential synchronization mechanism embedded in a browser. Summary of the Invention

[0004] To address the aforementioned technical problems, this invention provides a lightweight CAE geometry engine and a cloud-based real-time collaboration method, comprising the following steps: The cloud server obtains the original CAE geometric model, performs topology simplification and data compression on the original CAE geometric model, and generates a lightweight geometric data file containing multiple resolution levels; The cloud server obtains the network status parameters of each collaborative terminal, and dynamically sends the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters. The browser of the collaborative terminal loads the pre-compiled WebAssembly geometry engine module, parses the received lightweight geometry data file through the WebAssembly geometry engine module to build a geometric model in memory, and uses the view frustum culling algorithm to extract the geometric elements located in the current view and perform rendering. The collaborative terminal responds to the interactive operation on the geometric model, caches the operation record corresponding to the interactive operation in the local database, and performs a pre-render update on the geometric model locally based on the operation record through the WebAssembly geometry engine module, and extracts the differential data corresponding to the interactive operation. The collaborative terminal compresses the differential data, generates a differential data packet carrying a unique version number, and uploads it to the cloud server; The cloud server pushes the received difference data packet to other online collaborative terminals; the other collaborative terminals parse the unique version number carried by the difference data packet through the locally loaded WebAssembly geometry engine module, and perform operation replay update on the local geometry model according to the difference data contained in the difference data packet.

[0005] This invention also provides a lightweight CAE geometry engine and a cloud-based real-time collaboration system for implementing the aforementioned method, the system comprising: The cloud-based lightweight data module, deployed on a cloud server, is used to acquire the original CAE geometric model, perform topology simplification and data compression on the original CAE geometric model, and generate a lightweight geometric data file containing multiple resolution levels; and to acquire the network status parameters of each collaborative terminal, and dynamically distribute the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters. The WebAssembly geometry engine module is configured to load and run in the browser of the collaborative terminal, for parsing the received lightweight geometry data file to build a geometric model in memory, and using the view frustum culling algorithm to extract the geometric elements located in the current view for rendering. The browser-side interaction module runs in the browser of the collaborative terminal and is used to respond to interactive operations on the geometric model, cache the operation records corresponding to the interactive operations in the local database, and trigger the WebAssembly geometry engine module to perform pre-rendering updates on the geometric model locally based on the operation records. The difference synchronization module is used to extract the difference data corresponding to the interaction operation, compress the difference data, generate a difference data package carrying a unique version number and upload it to the cloud collaboration management module; and to receive the difference data package pushed by the cloud collaboration management module, parse the unique version number carried by the difference data package, and trigger the WebAssembly geometry engine module to perform operation replay update on the local geometry model according to the difference data contained in the difference data package. The cloud-based collaboration management module, deployed on the cloud server, is used to push the received difference data packets to the difference synchronization modules of other online collaboration terminals.

[0006] Compared with the prior art, the beneficial effects of the present invention are as follows: Lightweight and efficient rendering: The amount of original CAE model data is reduced by 90%-95%, and the WebAssembly engine achieves a rendering frame rate of 30-60fps for a 100,000-face model with an operation response latency of ≤100ms, breaking through the performance bottleneck of geometry processing on the browser side. Real-time collaboration and low-bandwidth synchronization: Differential data packet size ≤10KB, synchronization latency ≤500ms, bandwidth consumption reduced by 99.9% compared to full transmission, supporting real-time collaboration among multiple teams in different locations; Precise interaction and data security: The annotation and positioning accuracy is ≤0.1mm, and the geometric simplification deviation is ≤0.02mm, meeting the accuracy requirements of CAE preprocessing; browser-side operations are locally cached and cloud-based access control ensures that data is not lost and operations are traceable. Ecosystem compatibility: Supports mainstream browsers without requiring the installation of local software; compatible with original model formats such as STEP / IGES, and can be embedded into existing CAE workflows. Attached Figure Description

[0007] Figure 1 A flowchart provided for an embodiment of the present invention. Detailed Implementation

[0008] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms “comprising” or “having,” and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0009] like Figure 1 A lightweight CAE geometry engine and cloud-based real-time collaboration method, comprising the following steps: Step 1: The cloud server obtains the original CAE geometric model, performs topology simplification and data compression on the original CAE geometric model, and generates a lightweight geometric data file containing multiple resolution levels. Step 2: The cloud server obtains the network status parameters of each collaborative terminal, and dynamically sends the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters. Step 3: The browser of the collaborative terminal loads the pre-compiled WebAssembly geometry engine module, parses the received lightweight geometry data file through the WebAssembly geometry engine module to build a geometric model in memory, and uses the view frustum culling algorithm to extract the geometric elements located in the current view and perform rendering. Step 4: The collaborative terminal responds to the interactive operation for the geometric model, caches the operation record corresponding to the interactive operation in the local database, and performs pre-rendering update on the geometric model locally based on the operation record through the WebAssembly geometry engine module, and extracts the differential data corresponding to the interactive operation. Step 5: The collaborative terminal compresses the differential data to generate a differential data packet carrying a unique version number and uploads it to the cloud server. Step 6: The cloud server pushes the received difference data packet to other online collaborative terminals; the other collaborative terminals parse the unique version number carried by the difference data packet through the locally loaded WebAssembly geometry engine module, and perform operation replay update on the local geometry model according to the difference data contained in the difference data packet.

[0010] In step 1, performing topology simplification and data compression on the original CAE geometric model to generate a lightweight geometric data file containing multiple resolution levels includes: Extract the topological elements contained in the original CAE geometric model, and delete the topological elements whose feature size is smaller than a preset size reference ratio threshold and whose area is smaller than a preset area threshold. Extract the vertex coordinates and face indices of the retained topological elements, convert the vertex coordinates from floating-point format to fixed-point format, and perform Huffman coding to compress the face indices to generate compressed data in a custom binary format. The compressed data is used to generate a lightweight geometric data file containing high-definition resolution layers, standard-definition resolution layers, and thumbnail layers.

[0011] In step 2, dynamically sending the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters includes: If the latency value corresponding to the network status parameter is less than or equal to the first threshold, then the high-definition resolution data and the standard-definition resolution data are synchronously sent to the corresponding cooperating terminal. If the delay value corresponding to the network status parameter is greater than the first threshold and less than or equal to the second threshold, the standard definition resolution level data is preferentially sent to the corresponding cooperating terminal, and the high definition resolution level data is asynchronously sent in the background. If the latency value corresponding to the network status parameter is greater than the second threshold, the thumbnail layer data is preferentially sent to the corresponding collaborative terminal, and the standard definition resolution layer data and the high definition resolution layer data are loaded in sequence.

[0012] In step 3, the step of parsing the received lightweight geometry data file through the WebAssembly geometry engine module to build a geometric model in memory includes: Extract the three-dimensional coordinates of the center point of the geometric model, and translate the three-dimensional coordinates of the center point to the origin of the browser coordinate system; In step 4, after the WebAssembly geometry engine module performs a pre-render update on the geometric model locally based on the operation record, it further includes: The WebAssembly geometry engine module obtains the number of vertices, edges, and faces of the pre-rendered updated geometric model, and substitutes the number of vertices, edges, and faces into the simplified Euler formula to perform a topological check on the vertex connectivity of the face of the geometric model.

[0013] The interactive operations include geometric simplification operations and geometric annotation operations; When the interactive operation is the geometric simplification operation, the WebAssembly geometry engine module executes a face merging algorithm to merge the selected target face with its adjacent faces. The difference data includes a list of identifiers of the merged target faces and parameters of the new face generated after merging. When the interactive operation is the geometric annotation operation, the WebAssembly geometry engine module calls the WebGL picking algorithm to obtain the three-dimensional coordinates of the touch point on the model surface, and maps the three-dimensional coordinates to relative three-dimensional coordinates relative to the model origin. The differential data includes the relative three-dimensional coordinates and the annotation content data bound to the relative three-dimensional coordinates.

[0014] In step 6, the other collaborating terminals parse the unique version number carried in the difference data packet using the locally loaded WebAssembly geometry engine module, and perform operation replay updates on the local geometry model based on the difference data contained in the difference data packet, including: Determine whether the unique version number is continuous with the version sequence recorded locally. If they are continuous, directly apply the difference data to perform the operation replay update. If they are not continuous, send a request instruction to the cloud server to obtain the difference data packet corresponding to the missing version, and after receiving the missing difference data packet, perform the operation replay update in the version sequence order. When the cloud server concurrently receives differential data packets submitted by multiple collaborating terminals for the same topology element, it compares the timestamps of the multiple differential data packets, pushes the differential data packet with the earlier timestamp to each collaborating terminal, and issues an instruction containing conflict comparison data to the collaborating terminal from which the differential data packet with the later timestamp originated.

[0015] The method also includes steps for collaboration log management and historical version rollback: The cloud server records collaboration logs in the database, including operator identifiers, timestamps, difference data packet identifiers, and model version numbers. In response to a backtracking request for a target historical version initiated by a collaborative terminal, the cloud server extracts the basic full data packet corresponding to the target historical version, as well as all historical difference data packets from the initial state to the target historical version, and sends them to the collaborative terminal. The WebAssembly geometry engine module of the collaborative terminal loads the basic full data packet to reconstruct the geometric model, and replays the received historical difference data packets one by one in the order of the timestamps.

[0016] In embodiments of the present invention, a lightweight CAE geometry engine and a cloud-based real-time collaboration system are also included to implement the aforementioned method, the system comprising: The cloud-based lightweight data module, deployed on a cloud server, is used to acquire the original CAE geometric model, perform topology simplification and data compression on the original CAE geometric model, and generate a lightweight geometric data file containing multiple resolution levels; and to acquire the network status parameters of each collaborative terminal, and dynamically distribute the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters. The WebAssembly geometry engine module is configured to load and run in the browser of the collaborative terminal, for parsing the received lightweight geometry data file to build a geometric model in memory, and using the view frustum culling algorithm to extract the geometric elements located in the current view for rendering. The browser-side interaction module runs in the browser of the collaborative terminal and is used to respond to interactive operations on the geometric model, cache the operation records corresponding to the interactive operations in the local database, and trigger the WebAssembly geometry engine module to perform pre-rendering updates on the geometric model locally based on the operation records. The difference synchronization module is used to extract the difference data corresponding to the interaction operation, compress the difference data, generate a difference data package carrying a unique version number and upload it to the cloud collaboration management module; and to receive the difference data package pushed by the cloud collaboration management module, parse the unique version number carried by the difference data package, and trigger the WebAssembly geometry engine module to perform operation replay update on the local geometry model according to the difference data contained in the difference data package. The cloud-based collaboration management module, deployed on the cloud server, is used to push the received difference data packets to the difference synchronization modules of other online collaboration terminals.

[0017] The local database called by the browser-side interaction module is the IndexedDB database of the browser kernel; The difference synchronization module is configured to: when it detects that the communication connection between the collaborative terminal and the cloud server is disconnected, write the generated difference data packet into the IndexedDB database for local caching; and when it detects that the communication connection is restored, extract the locally cached difference data packet and upload it to the cloud collaboration management module.

[0018] The cloud-based collaboration management module includes a permission control unit; The permission control unit is used to assign operation permission levels, including modification permission, annotation permission and viewing permission, to each collaborative terminal, and generate permission configuration instructions to be sent to the collaborative terminal. After receiving the permission configuration instruction, the browser-side interaction module of the collaborative terminal dynamically restricts the triggering state of the functional components corresponding to the interactive operation on the front-end interactive interface according to the operation permission level.

[0019] Specifically, the core of this method is the technical chain of "lightweight data generation - efficient rendering by the Web engine - real-time interaction - differential synchronization - cloud collaboration". It overcomes the browser performance bottleneck by using WebAssembly to achieve low-bandwidth real-time synchronization with differential data packets. The specific steps are as follows: 1. Lightweight geometric data generation and distribution in the cloud 1.1 Lightweight processing of multi-granularity data: The cloud server receives the original CAE geometric model (STEP / IGES format, 1-10GB) and performs layered lightweight optimization: Topology simplification: Remove non-critical features (such as bolt holes with diameters less than 3% of the model's base size, or areas less than 1 mm²). 2 The number of topological elements is reduced by 60%-80% after simplification, while retaining the necessary geometric topology for CAE simulation (such as load application surfaces and stress concentration areas). Data compression: Geometric data is compressed using a "custom binary format (.webCAE)". Vertex coordinate quantization (precision preserved to 0.001mm, using 32-bit floating-point to 16-bit fixed-point conversion) and face index compression (based on Huffman coding) reduce the data size to 5%-10% of the original model (e.g., a 1GB STEP model is compressed into a 50-100MB .webCAE file). Multi-resolution adaptation: Generates 3-level resolution data (HD: for interactive annotation, patch error ≤0.01mm; SD: for quick preview, patch error ≤0.1mm; thumbnail: for list display, number of patches ≤1000), and automatically distributes the adapted resolution according to browser performance (number of CPU cores, video memory).

[0020] 1.2 Targeted Data Distribution Mechanism: The cloud dynamically adjusts the delivery strategy based on the collaboration team's permissions (e.g., "the design team can modify geometry, while the simulation team can only annotate") and network bandwidth (detected by ping values: ≤50ms is high speed, 50-100ms is medium speed, and >100ms is low speed). High-speed network (≤50ms): transmits HD + SD data, supports full-function interaction; Medium-speed network (50-100ms): Standard definition data is sent first (loaded within 10 seconds), and high definition data is sent asynchronously in the background; For low-speed networks (>100ms): first send thumbnails, then gradually load standard definition to high definition data to avoid loading lag.

[0021] 2. Deployment and rendering of the WebAssembly lightweight geometry engine 2.1 Engine Core Module Compilation and Loading: The C++ geometry processing core (including B-Rep parsing, patch rendering, and topology operations) is compiled into a WebAssembly (.wasm) module (≤5MB in size) using Emscripten. The browser loads it through the following process: Preloading phase: Load the .wasm module and dependent JavaScript glue code (≤100KB), and establish the communication interface between the engine and the browser DOM; Initialization phase: The engine reads the issued .webCAE file, parses the geometric topology (vertex, edge, face index), and builds a lightweight geometric model in memory (occupying ≤200MB of browser memory, 100,000-face model). Rendering optimization: Adopting "WebGL + frustum culling" technology, only the geometric elements in the current view are rendered (culling rate ≥70%, the rendering frame rate of 100,000-polygon models is increased to 30-60fps), and model rotation, scaling, and translation are supported (operation response latency ≤100ms).

[0022] 2.2 Browser-side geometric accuracy guarantee: The engine incorporates a "precision compensation algorithm" to address the precision loss issue of floating-point numbers in WebAssembly. Coordinate offset: The model center point is shifted to the origin of the browser coordinate system to reduce the floating-point truncation error of large coordinates (such as 10000mm); Topology verification: Real-time verification of the connectivity of facet vertices (based on the simplified Euler formula V-E+Fâ2) to ensure topological integrity after interactive operations (e.g., no free edges after deleting facets).

[0023] 3. Real-time geometric interaction and annotation on the browser side 3.1 Implementation of core interactive functions: It supports the geometric operations and annotations necessary for CAE preprocessing. The operation process is as follows: Geometric simplification: The user selects non-critical small faces (e.g., areas < 0.5 mm). 2 (Chamfering), click the "Simplify" button, and the engine will execute the "Face Merging Algorithm" (merging the small face with the adjacent large face, with a geometric deviation ≤0.02mm after merging), generating a simplified operation record (including operation type, target face ID, and deviation value); Precise annotation: Users click on the model to locate (accuracy ≤ 0.1mm, based on WebGL picking algorithm to obtain click coordinates), input annotation content (such as "bolt hole here needs to be repaired for gaps"), and the engine automatically associates the geometric coordinates of the annotation point (three-dimensional coordinates relative to the model origin) to generate annotations with coordinates (supports text, images, and hand-drawn lines). Collaborative comments: Users can reply to others' comments. The comment content is bound to the comment point and supports "@ specified user" (triggering a message notification). All interactive operations display the operator and timestamp (accurate to the second) in real time.

[0024] 3.2 Local caching and pre-rendering for interactive operations: To avoid operational delays caused by network fluctuations, the engine implements a three-level processing mechanism on the browser side: "local caching - pre-rendering - cloud synchronization". Local caching: User operation records (such as coordinate annotations and simplified parameters) are cached in real time to the browser's IndexedDB (size ≤ 50MB) to prevent loss when refreshing the page; Pre-rendering: The model rendering is updated locally immediately after the operation (such as real-time display of annotation points), without waiting for cloud synchronization, and the operation response latency is ≤100ms; Cloud synchronization: After the network is restored, the locally cached unsynchronized operations will be automatically uploaded to the cloud to ensure that no data is lost.

[0025] 4. Differential data packet generation and real-time synchronization with the cloud. 4.1 Difference Data Extraction Algorithm: To avoid retransmitting the entire model (saving bandwidth), the engine uses "incremental differential extraction" technology, generating only the difference data packets (.diff files) corresponding to the operations. The specific process is as follows: Operation feature extraction: Identify operation type (simplification / annotation / commentation) and extract key difference data (such as "deleted face ID list" and "parameters of new face after merging" for simplification operations, and "coordinates of annotation points" and "text content" for annotation operations); Data compression: LZ4 compression algorithm (compression rate ≥ 50%) is used for differential data, and the size of a single differential package is ≤ 10KB (e.g., the .diff file for annotation operations is only 2-3KB, and the simplified operation is ≤ 8KB). Version tagging: Assign a unique version number to each difference package (generated based on timestamp + random number, such as "20241001153000_8a3f") to ensure version order.

[0026] 4.2 Multi-team real-time synchronization mechanism: A "differential data distribution center" is deployed on a cloud server to enable real-time synchronization of operations across multiple teams. Push Trigger: When team A uploads the difference package, the server immediately checks the list of collaborating teams for the model (such as the design team and the simulation team) and pushes the difference package to all online teams via WebSocket (latency ≤ 500ms, accelerated by Alibaba Cloud / Tencent Cloud CDN). Difference application: After Team B's browser receives the difference package, the engine parses the version number (if the versions are consecutive, apply directly; if the versions jump, request the difference package for the missing version first), and performs "operation replay" (such as performing simplification based on the face ID list in the difference package and displaying annotations based on coordinates). After application, the model is consistent with Team A in real time (synchronization accuracy ≤ 0.01mm). Conflict resolution: If two teams modify the same geometric element at the same time (such as simplifying the same chamfer at the same time), the server adopts a conflict strategy of "timestamp priority + user permission assistance" (the user who operates later receives a conflict prompt and can choose to "abandon their operation" or "force overwrite", and a comparison of the operations of both parties is attached).

[0027] 5. Cloud-based collaboration management and access control 5.1 Multi-role access control: The cloud system supports fine-grained permission configuration (assigning permissions by team / user), with permission levels divided into: Administrator: Has full permissions (can modify models, delete other people's operations, and manage team permissions); Editors: Can perform geometric simplification, annotation, and commenting, but cannot delete others' work; Viewers can only browse the model and view annotations / comments; they cannot perform any modification operations. Permission configuration takes effect in real time (the server pushes a notification of permission changes, and the browser immediately restricts the availability of the corresponding operation buttons).

[0028] 5.2 Collaboration Logs and Version Rollback: All collaborative operation logs are recorded in the cloud (including operator, time, difference package ID, and model version), and the "version rollback" function is supported. Version list: Displays all model versions in chronological order (including version number, operation summary, and operator), and users can view the status of any model version; Backtracking operation: When the user selects a historical version, the server sends the "full base package + all difference packages to this version" for that version. The engine replays the difference packages on the browser side to restore the historical version model (backtracking time ≤ 10 seconds for a version with 100 difference packages). Operation audit: Administrators can export collaboration logs (supporting Excel / PDF format) for auditing the collaboration process (such as tracing "who performed a simplified operation and whether it was compliant").

[0029] II. Lightweight CAE Geometry Engine and Cloud Real-Time Collaboration System Based on WebAssembly This system is the hardware and software implementation of the above method, including 6 core functional modules. Each module works together through standardized interfaces to form a bidirectional interactive architecture between the cloud and the browser: Cloud Data Lightweight Module Alibaba Cloud ECS server (8 cores, 16GB), LZ4 compression library; receives the original CAE model, performs topology simplification and data compression, and generates multi-resolution .webCAE files; a 1GB STEP model is compressed into a 50-100MB .webCAE file, with a processing time of ≤5 minutes.

[0030] WebAssembly geometry engine module Emscripten 3.1.47 (compilation tool) and WebGL 2.0 are compiled into .wasm; the module (≤5MB) implements browser-side geometry parsing, rendering, and local caching; the rendering frame rate for a 100,000-face model is 30-60fps, and the operation response latency is ≤100ms.

[0031] Browser-side interaction module JavaScript (ES6+), IndexedDB; provides geometric simplification, precise annotation, and collaborative commenting functions, with local caching of operation records; annotation positioning accuracy ≤0.1mm, and simplified geometric deviation ≤0.02mm.

[0032] Difference synchronization module WebSocket (accelerated by Alibaba Cloud CDN), LZ4 compression; generates differential data packets (.diff≤10KB) to achieve real-time synchronization between the cloud and the browser; synchronization latency ≤500ms, differential packet compression rate ≥50%.

[0033] Cloud-based collaboration management module MySQL database (storage permissions / logs), WebSocket service; manages team permissions, distributes difference packages, records collaboration logs, and supports version rollback; permission activation delay ≤ 1 second, rollback time for 100 difference packages ≤ 10 seconds.

[0034] Message notification module Alibaba Cloud SMS / email API and browser; Notification API triggers @user notifications (SMS / email / browser pop-up) to remind users of unread annotations / comments; notification delivery delay ≤3 seconds, and unread message marking accuracy is 100%.

[0035] Taking "multiple teams in an aerospace company collaborating on CAE pretreatment of engine blades" as an example, the implementation process of this invention is explained in detail: 1. Implementation conditions Collaboration team: OEM design team (Beijing), supplier simulation team (Shanghai), third-party audit team (Shenzhen), totaling 10 people; Original CAE model: Engine blade STEP format model (2.5GB, containing 1.2 million facets, key feature: blade leading edge (curvature 0.8mm)). -1 ), bolt hole (φ8mm)); Hardware / Software Environment: 1. Cloud: Deploy the system of this invention on an Alibaba Cloud ECS server (16 cores, 32GB, 100Mbps bandwidth); 2. Browser: Chrome 120.0+ (supports WebAssembly and WebGL 2.0), network environment (Beijing / Shanghai: 50Mbps broadband, ping value ≤30ms; Shenzhen: 20Mbps broadband, ping value ≤60ms).

[0036] 2. Implementation Steps Step 1: Lightweight Cloud Data Generation and Distribution The OEM administrator uploaded a 2.5GB blade STEP model to the cloud, and the system performed lightweight processing: 1. Topology simplification: Remove non-critical features (such as small chamfers with a diameter of <1mm at the blade root, resulting in the removal of 8000 small faces), while retaining critical features such as the leading edge and bolt holes; 2. Data Compression: Converted to .webCAE format, the compressed size is 120MB (compression rate 95.2%), generating two resolution levels of data: high definition (pixel error ≤0.01mm) and standard definition (≤0.1mm); The system sends data based on the team's network environment: 1. Beijing / Shanghai team (high-speed network): Simultaneously downloads HD + SD data (120MB + 30MB), loading complete within 15 seconds; 2. Shenzhen team (medium-speed network): First, send standard definition data (30MB, 8 seconds to load), then send high definition data asynchronously in the background (120MB, 30 seconds to load).

[0037] Step 2: WebAssembly engine loading and model rendering Each team's browser loads the .wasm engine module (4.8MB) and JavaScript glue code (80KB) to initialize the engine; The engine parses .webCAE files, builds in-memory geometric models (occupying 180MB of browser memory), and uses WebGL + frustum culling for rendering. 1. When the Beijing team inspected the leading edge of the blade, the engine removed 75% of the non-viewable inner surfaces, the rendering frame rate was 55fps, and the operation rotation / scaling latency was ≤80ms; 2. When the Shenzhen team inspected the bolt holes, standard definition data was rendered first (40fps), and high definition data was loaded and automatically switched (52fps), with no obvious lag.

[0038] Step 3: Real-time interaction and annotation on the browser side The Shanghai simulation team discovered small gaps around the bolt holes and performed the following operations: 1. Click the "Annotate" button, click to locate the bolt hole edge (obtain coordinates (125.32, 48.65, 20.18) mm), and enter the annotation: "There is a 0.08 mm gap in the bolt hole here, which needs to be repaired", @Beijing Design Team; 2. The engine renders the marker points (red dots + text bubbles) locally in real time, and caches the operation records in IndexedDB; The Beijing design team received a browser pop-up notification ("@you: bolt hole annotation"). Click to view the annotation and reply in the comments: "It will be fixed within 2 hours and synchronized after the fix"; The Shenzhen review team reviewed the model and performed a "simplification" operation on the leading edge of the blade (deleting areas <0.3mm). 2 (Small protrusions), engine merges small faces (misalignment after merging is 0.015mm), generating a simplified operation .diff package (6.2KB).

[0039] Step 4: Difference Synchronization and Collaboration Management The annotation operations performed by the Shanghai team generated a .diff file (2.8KB), which was automatically uploaded to the cloud. The server then pushed the file to the Beijing and Shenzhen teams via WebSocket. 1. The Beijing team's browser receives the .diff packet within 500ms, and the engine parses it and displays the annotation points in real time without refreshing the page; 2. The Shenzhen team can also see the annotation and reply to the comment directly; After the Beijing team repaired the bolt holes, they performed a "simplified" operation (repairing the gaps and generating new surfaces), uploaded the .diff package (7.5KB), and synchronized it to the Shanghai and Shenzhen teams via the cloud. The Shanghai team checked the repaired model and confirmed that the gaps had disappeared (geometric deviation 0.008mm). Administrators can view collaboration logs in the cloud and export them in Excel format (containing operation records of 10 people, totaling 32 operations). Audits show no violations. When it is necessary to revert to the "simplified operation of the Shenzhen team", the corresponding version is selected, and the system issues a basic package plus 5 difference packages, restoring the model of that version within 10 seconds.

[0040] 3. Implementation Results Collaboration efficiency: Model transmission time is reduced from 1 hour (2.5GB) for traditional full transmission to 15-30 seconds (120MB webCAE), multi-team synchronization latency is ≤500ms, and the collaboration cycle is reduced from 72 hours to 24 hours; Interactive experience: The rendering frame rate of the 1.2 million polygon model is 30-60fps, the operation response latency is ≤100ms, and the annotation accuracy is ≤0.1mm, which meets the accuracy requirements of CAE preprocessing. Bandwidth saving: The size of the difference packet is ≤10KB, which saves 99.9% of the bandwidth compared to the full model transmission (e.g., the total difference data of 32 operations is only 200KB, while full transmission requires 120MB×32=3.84GB).

[0041] 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 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 the present invention.

Claims

1. A lightweight CAE geometry engine and a cloud-based real-time collaboration method, characterized in that, Includes the following steps: Step 1: The cloud server obtains the original CAE geometric model, performs topology simplification and data compression on the original CAE geometric model, and generates a lightweight geometric data file containing multiple resolution levels. Step 2: The cloud server obtains the network status parameters of each collaborative terminal, and dynamically sends the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters. Step 3: The browser of the collaborative terminal loads the pre-compiled WebAssembly geometry engine module, parses the received lightweight geometry data file through the WebAssembly geometry engine module to build a geometric model in memory, and uses the view frustum culling algorithm to extract the geometric elements located in the current view and perform rendering. Step 4: The collaborative terminal responds to the interactive operation for the geometric model, caches the operation record corresponding to the interactive operation in the local database, and performs pre-rendering update on the geometric model locally based on the operation record through the WebAssembly geometry engine module, and extracts the differential data corresponding to the interactive operation. Step 5: The collaborative terminal compresses the differential data to generate a differential data packet carrying a unique version number and uploads it to the cloud server. Step 6: The cloud server pushes the received difference data packet to other online collaborative terminals; The other collaborating terminals parse the unique version number carried in the difference data packet through the locally loaded WebAssembly geometry engine module, and perform operation replay updates on the local geometry model according to the difference data contained in the difference data packet.

2. The method according to claim 1, characterized in that, In step 1, performing topology simplification and data compression on the original CAE geometric model to generate a lightweight geometric data file containing multiple resolution levels includes: Extract the topological elements contained in the original CAE geometric model, and delete the topological elements whose feature size is smaller than a preset size reference ratio threshold and whose area is smaller than a preset area threshold. Extract the vertex coordinates and face indices of the retained topological elements, convert the vertex coordinates from floating-point format to fixed-point format, and perform Huffman coding to compress the face indices to generate compressed data in a custom binary format. The compressed data is used to generate a lightweight geometric data file containing high-definition resolution layers, standard-definition resolution layers, and thumbnail layers.

3. The method according to claim 2, characterized in that, In step 2, dynamically sending the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters includes: If the latency value corresponding to the network status parameter is less than or equal to the first threshold, then the high-definition resolution data and the standard-definition resolution data are synchronously sent to the corresponding cooperating terminal. If the delay value corresponding to the network status parameter is greater than the first threshold and less than or equal to the second threshold, the standard definition resolution level data is preferentially sent to the corresponding cooperating terminal, and the high definition resolution level data is asynchronously sent in the background. If the latency value corresponding to the network status parameter is greater than the second threshold, the thumbnail layer data is preferentially sent to the corresponding collaborative terminal, and the standard definition resolution layer data and the high definition resolution layer data are loaded in sequence.

4. The method according to claim 1, characterized in that, In step 3, the step of parsing the received lightweight geometry data file through the WebAssembly geometry engine module to build a geometric model in memory includes: Extract the three-dimensional coordinates of the center point of the geometric model, and translate the three-dimensional coordinates of the center point to the origin of the browser coordinate system; In step 4, after the WebAssembly geometry engine module performs a pre-render update on the geometric model locally based on the operation record, it further includes: The WebAssembly geometry engine module obtains the number of vertices, edges, and faces of the pre-rendered updated geometric model, and substitutes the number of vertices, edges, and faces into the simplified Euler formula to perform a topological check on the vertex connectivity of the face of the geometric model.

5. The method according to claim 1, characterized in that, The interactive operations include geometric simplification operations and geometric annotation operations; When the interactive operation is the geometric simplification operation, the WebAssembly geometry engine module executes a face merging algorithm to merge the selected target face with its adjacent faces. The difference data includes a list of identifiers of the merged target faces and parameters of the new face generated after merging. When the interactive operation is the geometric annotation operation, the WebAssembly geometry engine module calls the WebGL picking algorithm to obtain the three-dimensional coordinates of the touch point on the model surface, and maps the three-dimensional coordinates to relative three-dimensional coordinates relative to the model origin. The differential data includes the relative three-dimensional coordinates and the annotation content data bound to the relative three-dimensional coordinates.

6. The method according to claim 1, characterized in that, In step 6, the other collaborating terminals parse the unique version number carried in the difference data packet using the locally loaded WebAssembly geometry engine module, and perform operation replay updates on the local geometry model based on the difference data contained in the difference data packet, including: Determine whether the unique version number is continuous with the version sequence recorded locally. If they are continuous, directly apply the difference data to perform the operation replay update. If they are not continuous, send a request instruction to the cloud server to obtain the difference data packet corresponding to the missing version, and after receiving the missing difference data packet, perform the operation replay update in the version sequence order. When the cloud server concurrently receives differential data packets submitted by multiple collaborating terminals for the same topology element, it compares the timestamps of the multiple differential data packets, pushes the differential data packet with the earlier timestamp to each collaborating terminal, and issues an instruction containing conflict comparison data to the collaborating terminal from which the differential data packet with the later timestamp originated.

7. The method according to claim 1, characterized in that, It also includes steps for collaboration log management and historical version rollback: The cloud server records collaboration logs in the database, including operator identifiers, timestamps, difference data packet identifiers, and model version numbers. In response to a backtracking request for a target historical version initiated by a collaborative terminal, the cloud server extracts the basic full data packet corresponding to the target historical version, as well as all historical difference data packets from the initial state to the target historical version, and sends them to the collaborative terminal. The WebAssembly geometry engine module of the collaborative terminal loads the basic full data packet to reconstruct the geometric model, and replays the received historical difference data packets one by one in the order of the timestamps.

8. A lightweight CAE geometry engine and cloud-based real-time collaboration system, characterized in that, The system for implementing the method as described in any one of claims 1 to 7 includes: The cloud-based lightweight data module, deployed on a cloud server, is used to acquire the original CAE geometric model, perform topology simplification and data compression on the original CAE geometric model, and generate a lightweight geometric data file containing multiple resolution levels; and to acquire the network status parameters of each collaborative terminal, and dynamically distribute the lightweight geometric data file adapted to the resolution level to the corresponding collaborative terminal according to the network status parameters. The WebAssembly geometry engine module is configured to load and run in the browser of the collaborative terminal, for parsing the received lightweight geometry data file to build a geometric model in memory, and using the view frustum culling algorithm to extract the geometric elements located in the current view for rendering. The browser-side interaction module runs in the browser of the collaborative terminal and is used to respond to interactive operations on the geometric model, cache the operation records corresponding to the interactive operations in the local database, and trigger the WebAssembly geometry engine module to perform pre-rendering updates on the geometric model locally based on the operation records. The difference synchronization module is used to extract the difference data corresponding to the interaction operation, compress the difference data, generate a difference data package carrying a unique version number and upload it to the cloud collaboration management module; and to receive the difference data package pushed by the cloud collaboration management module, parse the unique version number carried by the difference data package, and trigger the WebAssembly geometry engine module to perform operation replay update on the local geometry model according to the difference data contained in the difference data package. The cloud-based collaboration management module, deployed on the cloud server, is used to push the received difference data packets to the difference synchronization modules of other online collaboration terminals.

9. The system according to claim 8, characterized in that, The local database called by the browser-side interaction module is the IndexedDB database of the browser kernel; The difference synchronization module is configured to: when it detects that the communication connection between the collaborative terminal and the cloud server is disconnected, write the generated difference data packet into the IndexedDB database for local caching; and when it detects that the communication connection is restored, extract the locally cached difference data packet and upload it to the cloud collaboration management module.

10. The system according to claim 8, characterized in that, The cloud-based collaboration management module includes a permission control unit; The permission control unit is used to assign operation permission levels, including modification permission, annotation permission and viewing permission, to each collaborative terminal, and generate permission configuration instructions to be sent to the collaborative terminal. After receiving the permission configuration instruction, the browser-side interaction module of the collaborative terminal dynamically restricts the triggering state of the functional components corresponding to the interactive operation on the front-end interactive interface according to the operation permission level.

Images