Low-delay quasi-real-time digital twinborn visualization system and method, storage medium and product
By embedding AI models and event control buses in the digital twin system and adopting multi-threaded parallel processing and vtk.js rendering pipeline, the latency and refresh rate issues of the digital twin system are solved, and efficient physical field rendering and real-time optimization are achieved.
Patent Information
- Application Number
- CN202510635074.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-05-16
- Publication Date
- 2025-09-12
AI Technical Summary
Existing digital twin systems have problems such as long visualization delay, low refresh rate and poor operation optimization when rendering physical fields, making it difficult to meet the real-time rendering requirements in highly dynamic scenes.
A low-latency, quasi-real-time digital twin visualization system is adopted. By embedding AI models and event control buses, combined with multi-threaded parallel processing and vtk.js rendering pipeline, efficient rendering and high-frequency refresh of physical field data are achieved.
It significantly reduces system latency, improves the refresh rate of physical field data and the stability of front-end rendering, enhances the smoothness and operational efficiency of the system, and supports real-time industrial production and optimization operations.
Smart Images
Figure CN120632233A_ABST
Abstract
Description
Technical Field
[0001] The present invention belongs to the field of digital twins, and more specifically, relates to a low-latency, quasi-real-time digital twin visualization system, method, storage medium, and product. Background Art
[0002] Digital twin technology, a universal method for visualizing physical fields, relies on reconstructing complete physical field data from the limited information provided by distributed control systems (DCSs) through simulation technology, and transforming this data into a three-dimensional image of the physical field using visualization technology. However, the real-time and smooth performance of existing digital twin systems cannot meet actual production needs. Specifically, existing digital twin systems often face the following problems when rendering physical fields:
[0003] Long visualization delays: Due to the complexity of simulation calculations and rendering processes, existing digital twin systems experience significant delays when generating and updating 3D images of the physical field. This delay not only affects users' real-time perception of physical field changes but also limits real-time decision-making and optimization operations based on digital twin systems.
[0004] Low refresh rate: Existing digital twin systems have a low refresh rate when rendering physical fields, which cannot meet the real-time rendering requirements of highly dynamic scenes. This is particularly prominent in physical fields with high-frequency changes, such as vibration analysis of high-speed rotating machinery and rapidly changing temperature fields.
[0005] Poor operational optimization results: In industrial production and operational optimization, digital twin systems are widely used to simulate and predict the impact of different operational strategies on production results. However, due to visualization latency issues, existing digital twin systems cannot smoothly display the real-time changes in production results caused by operational optimization operations, making it difficult to accurately evaluate and verify optimization results.
[0006] In summary, the existing digital twin systems have obvious deficiencies in terms of visualization delay, refresh rate, and operation optimization effect. Therefore, there is an urgent need for a low-latency and high-refresh-rate technical solution that can achieve real-time rendering of physical fields to improve the smoothness of the digital twin system and better support industrial production and operation optimization. Summary of the Invention
[0007] In response to the above-mentioned defects or improvement needs of the prior art, the present invention provides a low-latency, quasi-real-time digital twin visualization system, method, storage medium and product, the purpose of which is to improve the real-time and smoothness of the digital twin system.
[0008] To achieve the above objectives, according to a first aspect of the present invention, a low-latency, quasi-real-time digital twin visualization system is proposed, comprising a front-end visualization module and a back-end digital physical field generation module, wherein:
[0009] The front-end visualization module includes a rendering unit and an event control bus, wherein the rendering unit includes multiple rendering components for rendering physical field data into images; the event control bus includes a control center component and an event center, the control center component is used to monitor the rendering status of each rendering component, and the event center is shared by the control center component and the rendering component and is used to realize communication between the control center component and each rendering component;
[0010] The back-end digital physical field generation module includes a data access unit, a physical field reconstruction unit, a global cache area and an HTTP service unit, wherein the data access unit is used to obtain measurement point data from the distributed control system in real time; the physical field reconstruction unit is embedded with an AI model, which is used to obtain physical field data based on the measurement point data; the global cache area is used to store physical field data in real time; the HTTP service unit is used to receive HTTP requests from the control center component and send the physical field data in the global cache area to the rendering unit.
[0011] As a further preference, the physical field reconstruction unit includes an AI model and an analysis model, wherein the AI model is used to reconstruct the physical field according to the measurement point data, and the analysis model is used to obtain physical field statistical information according to the reconstructed physical field analysis.
[0012] As a further preferred embodiment, the rendering unit includes a three-dimensional physical field rendering component, a two-dimensional physical field rendering component and a statistical information rendering component. The three-dimensional physical field rendering component and the two-dimensional physical field rendering component are used to render and display the three-dimensional physical field and the two-dimensional physical field based on the reconstructed physical field, and the statistical information rendering component is used to render and display statistical information based on the physical field statistical information.
[0013] As a further preferred embodiment, the rendering unit further includes an alarm component, which is used to display alarm information when statistical information exceeding a threshold value appears in the statistical information rendering component.
[0014] As a further preference, the tasks of the physical field reconstruction unit are executed in an unconditional loop mode.
[0015] As a further preference, the physical field reconstruction unit and HTTP service unit tasks are deployed in a dual-threaded task mode.
[0016] As a further preference, each rendering component in the rendering unit adopts the vtk.js rendering pipeline.
[0017] According to a second aspect of the present invention, a digital twin visualization method based on the above-mentioned low-latency quasi-real-time digital twin visualization system is provided, comprising the following steps:
[0018] The data access unit obtains the measurement point data from the distributed control system in real time, and the physical field reconstruction unit obtains the physical field data based on the measurement point data and stores the physical field data in the global cache in real time;
[0019] When accessing the server, the control center component sends a rendering start event to the event center. The rendering unit receives the rendering start event via the event center. The rendering unit sends an HTTP request to the HTTP service unit to obtain the physical field data in the global cache. Each rendering component schedules the client GPU to render the physical field data into an image. After each rendering component completes rendering, the rendering unit broadcasts the rendering completion information to the event control bus, triggering the control center component to request to start the next rendering.
[0020] According to a third aspect of the present invention, a computer-readable storage medium is provided, on which a computer program is stored, and when the computer program is executed by a processor, the digital twin visualization method is implemented.
[0021] According to a fourth aspect of the present invention, a computer program product is provided, comprising a computer program, which implements the above-mentioned digital twin visualization method when executed by a processor.
[0022] In general, the above technical solutions conceived by the present invention have the following technical advantages compared with the existing technology:
[0023] 1. Embedded AI model significantly improves HTTP response speed: A pre-trained AI model program is embedded in the main process, allowing AI prediction results to be directly stored in the global cache. This avoids cross-process communication of AI prediction results or the process of reading AI prediction results from hard disk media, thereby significantly shortening the time overhead for the backend to return AI prediction results and reducing the latency of the physical field digital twin visualization system.
[0024] 2. Non-stop AI prediction significantly improves the refresh rate of back-end data to be rendered: The back-end code loops and immediately starts the next calculation after completing one, maximizing the high prediction performance of the AI model to improve the refresh rate of physical field data.
[0025] 3. Event control bus to achieve high-frequency and stable refresh of front-end physical field graphics: The control center component sends a rendering start event, and each type of data rendering component on the bus starts rendering after receiving the rendering start event and the data to be rendered. Since the control center component and the rendering component share an event center, once the rendering is completed, each rendering component broadcasts the rendering completion information to the control bus, triggering the control center component to send the next rendering start event, thereby achieving stability under high-frequency refresh conditions for complex multi-component front-end systems.
[0026] 4. HTTP service, AI calculation, and data storage are three threads running in parallel to improve the AI prediction performance of the main thread: Data calculation and cache access are assigned to thread tasks separately, forming a synchronous execution program for calculation and cache access IO operations. This fully utilizes the CPU processing power even on a single-core server, significantly improving the system's operating efficiency.
[0027] 5. vtk.js rendering pipeline enables efficient rendering of physical fields: The vtk.js rendering pipeline is further adopted, which can call the computer GPU for web-side 3D volume rendering. Its built-in algorithm is very suitable for accurate and high-speed rendering of physical field data. By embedding vtk.js for 3D graphics rendering, the rendering speed of large-scale 3D physical field data is greatly improved. BRIEF DESCRIPTION OF THE DRAWINGS
[0028] Figure 1 This is a schematic diagram of the low-latency, quasi-real-time digital twin visualization process according to an embodiment of the present invention;
[0029] Figure 2 This is a schematic diagram of the backend architecture of the AI model and HTTP service "thread independence-data interaction" in an embodiment of the present invention;
[0030] Figure 3 This is a logic diagram of the event control bus according to an embodiment of the present invention;
[0031] Figure 4 This is a rendering logic diagram for efficient visualization of the physical field according to an embodiment of the present invention. DETAILED DESCRIPTION
[0032] In order to make the objectives, technical solutions and advantages of the present invention more clearly understood, the present invention is further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely for the purpose of explaining the present invention and are not intended to limit the present invention. In addition, the technical features involved in the various embodiments of the present invention described below may be combined with each other as long as they do not conflict with each other.
[0033] The embodiment of the present invention provides a low-latency, quasi-real-time digital twin visualization system, such as Figure 1 As shown, it includes a back-end digital physical field generation module and a front-end visualization module, where:
[0034] (1) The back-end digital physical field generation module includes a data access unit, a physical field reconstruction unit, an HTTP service unit, and a global cache area:
[0035] The data access unit is used to obtain the measurement point data from the distributed control system DCS database in real time and store the physical field data in the global buffer area.
[0036] The physical field reconstruction unit is used to obtain physical field data based on the measurement point data. The physical field data includes two categories: one is the three-dimensional physical field reconstructed by AI, and the other is the physical field statistical information obtained by generating the three-dimensional digital physical field; specifically, the physical field reconstruction unit includes a digital twin AI model and an analysis model. The AI model is used to reconstruct the physical field based on real-time dynamic measurement point data, and the analysis model is used to obtain physical field statistical information based on the analysis of the reconstructed physical field.
[0037] The HTTP service unit is used to accept HTTP requests from the rendering unit and send the physical field data in the global buffer to the rendering unit.
[0038] Furthermore, the AI model performs predictions through an unconditional loop, making the most of the high prediction performance of the AI model to improve the refresh rate of physical field data. In addition, the back-end program has an embedded AI model, but the thread that executes the AI prediction task is independent of the thread to which the HTTP service unit belongs. Any element of the latter is irrelevant to the execution conditions of the former. The data sharing between the AI prediction module and the HTTP service unit significantly reduces the back-end HTTP response latency. Data calculation and global cache access are assigned thread tasks separately, forming a synchronous execution program for calculation and global cache access IO operations, which can fully call on the CPU processing power even on a single-core server, significantly improving the system's operating efficiency.
[0039] (2) The front-end visualization module includes a rendering unit and an event control bus:
[0040] The rendering unit includes multiple rendering components for rendering physical field data into images.
[0041] Specifically, the rendering component is divided into a three-dimensional physical field rendering component, a two-dimensional physical field rendering component, a statistical information rendering component and an alarm component. The three-dimensional physical field rendering component and the two-dimensional physical field rendering component are used to render and display the three-dimensional physical field and the two-dimensional physical field based on the reconstructed physical field. The statistical information rendering component is used to render and display statistical information based on the physical field statistical information; the alarm component is used to display alarm information when the physical field data exceeds a preset threshold.
[0042] The event control bus includes the control center component (index.vue) and the event center. The control center component is used to control and monitor the rendering status of each rendering component; the event center is shared by the control center component and each rendering component and is used to realize communication between the control center component and each rendering component.
[0043] Specifically, the event control bus allows all components to share the same event center and register to send or receive events with the center, so that components can notify other components in parallel. This approach provides a loosely coupled event communication mechanism, allowing components to easily interact with each other, and provides a centralized way to manage events, making it easy to monitor and trigger cross-component events.
[0044] Furthermore, in order to be able to replay the historical physical field evolution process in accident cause analysis, the digital twin system needs to store historical physical field data. The back-end of the present invention can form a four-dimensional time series and three-dimensional matrix of the physical field at the back-end by reading the historical measurement point data of the DCS system. It can accept the replay time start and end time parameters of the front-end HTTP request, and innovatively access the historical database through sub-threads. It samples historical data points from the data set between the start and end points of the historical data to reconstruct the historical physical field evolution process. The sampling interval can be set by the client to reconstruct the historical physical field evolution process with different time resolutions.
[0045] The low-latency, near-real-time digital twin visualization system described above works as follows:
[0046] When the client opens the visualization interface in the browser, such as Figure 3 As shown, the control center component of the event control bus sends an HTTP request to the backend. Leveraging the event bus's ability to allow all components to share the same event center, it sends a render start event to the center. Each rendering component on the bus receives the render start event and the data to be rendered and initiates rendering. Once rendering is complete, each component broadcasts the completion information to the event center, triggering the control center component to issue a new data request to initiate the next rendering. This ensures stable execution of high-frequency front-end updates. Rendering of each rendering component is accomplished using the vtk.js rendering pipeline, specifically designed for physics-based visualization. This includes geometry rendering, volume rendering, image processing, slicing, and isosurfaces. Users can interact with 3D visualization objects using devices such as a mouse and keyboard, observing model details from various angles, enhancing the user experience of the digital twin visualization system. After the client system requests data from the backend, the vtk.js program renders this data into a 3D image according to the user-defined rendering pipeline. This allows the physics matrix to be rendered into an image of the flow and combustion within the furnace, which is then presented in the browser interface along with key information.
[0047] In the backend server, such as Figure 2As shown, the HTTP service unit receives the request and maps it to the corresponding view function. After receiving the user request, the view function processes it, reads the physics reconstruction unit's calculation results from the global cache, and returns them to the client in the form of a binary stream, improving network data transmission speed. Simultaneously, during the execution of the physics reconstruction unit's task, the data access unit obtains real-time measurement point data from the DCS system. This measurement point data is then input into the AI model to reconstruct the physical field, and the results are stored in the global cache. The physics reconstruction unit's tasks are executed in an unconditional loop, allowing the data access and physics reconstruction tasks to immediately proceed to the next one upon completion, thus achieving high-frequency data refresh. The calculation results are also periodically saved to the global cache via the data access unit, along with key statistical information about the physics reconstruction results. The physics reconstruction unit and HTTP service unit tasks are deployed in a dual-threaded task mode. The two tasks are decoupled and executed in parallel, resulting in a synchronized execution of calculations and global cache access I / O operations. This fully utilizes the CPU processing power even on a single-core server, significantly improving system efficiency.
[0048] The specific construction process of the low-latency quasi-real-time digital twin visualization system in this implementation is as follows:
[0049] S1. Build a digital physical field generation module, which includes a data access unit, a physical field reconstruction unit, an HTTP service unit, and a Django backend with a global cache. This module is used to collect real-time sensor data, schedule AI models to reconstruct the physical field, perform statistical analysis of the physical field, and respond to HTTP requests from client visualization programs. It sends the reconstructed physical field matrix and the statistical information obtained from the secondary analysis of the reconstructed physical field to the front end for rendering. Specifically, it includes:
[0050] S101. Constructing a data access unit:
[0051] At the architectural design level, a request identification module is embedded to capture requests from the HTTP service unit. This module classifies received requests based on a preset set of classification rules, distinguishing them into requests requiring database data retrieval and other categories. For requests involving database data retrieval, a subunit is constructed to generate appropriate RESTful-style query statements. This subunit is preloaded with a field mapping table and a grammar rule library. Based on the request details, such as a request for historical physical field data for a specific time period, it references the mapping table to locate the corresponding database table name, "phyS10ical_field_hiS10tory." Combined with the grammar rule library, it generates a query statement such as "S10ELECT * FROM phyS10ical_field_hiS10tory WHERE time BETWEEN 'S10tart_time' AND 'end_time'." Furthermore, a database connection pooling technology module is incorporated, with a built-in connection allocation algorithm that dynamically allocates idle connections based on the system's real-time load and connection availability. When there is a query requirement, a valid connection to the database is allocated for the query statement to ensure that the query statement is smoothly delivered to the database, thereby completing the complete construction of the data access unit from architecture to functional implementation.
[0052] S102. Construct a physical field reconstruction unit including a digital twin AI model and an analysis model.
[0053] S103. Build HTTP service unit:
[0054] In accordance with the HTTP protocol standard specifications, a set of parsing logic code sets was developed using professional programming tools. They were encapsulated into independently running program units and integrated into the core processing area of the service unit. They are specifically responsible for disassembling and extracting key information such as the request method (such as GET, POS10T, etc.), request path, request parameters, etc. in the request header.
[0055] For the two types of function execution paths, there are the following targeted construction steps:
[0056] 1) Construction of request interaction for the global cache of physical field data: Design and develop an internal communication interface module adapted for docking with the global cache. Based on the receiving format requirements of the global cache, formulate the generation rules of data structure templates (such as JSON format data packets), and write conversion code to ensure that the parsed request data can be encapsulated according to the rules and accurately transmitted to the global cache.
[0057] 2) Build a module specifically for historical data requests from the database: Based on an analysis of specific business processing requirements, a dedicated module for generating packets for historical data requests was built. By researching the patterns of historical data query requirements, algorithms for extracting key query elements, such as time range and data type, were established and integrated into the module code, enabling on-demand data packet generation. Furthermore, a high-speed data transmission channel directly connected to the data access unit was established, using high-speed transmission cables and optimizing the interface protocols at both ends to ensure high-speed and stable data packet transmission, enabling efficient data flow.
[0058] S104: Construct a global cache area for physical field data.
[0059] S105. Constructing a data access unit and an interface with a physical field reconstruction unit:
[0060] Build the data post-processing architecture of the data access unit. Once the unit successfully receives return data from the database, it immediately initiates the built-in data processing pipeline. In the construction of the cleaning module, based on pre-defined data quality standards, we develop noise value identification algorithms and missing value location code. These programs screen the data, accurately removing noise values that significantly deviate from the normal range. At the same time, we apply appropriate imputation strategies, such as filling missing values based on data trends or surrounding valid values.
[0061] After completing the cleaning and preprocessing steps, the data format conversion phase begins. Based on the input requirements of the AI model in the physical field reconstruction unit, an adaptive format conversion program is developed to ensure that the data can be smoothly accepted by the model. Subsequently, a model call interface module is constructed to interface with the physical field reconstruction unit. This module adheres to the data transmission protocol agreed upon by both parties and transmits the processed data stably and efficiently.
[0062] The physical field reconstruction unit quickly activates the built-in prediction startup program upon receiving data from the data access unit. Within the prediction calculation section, a dynamic prediction code segment based on loop syntax is written. This code segment continuously captures new incoming data in real time and predicts the results based on the existing model algorithm, enabling dynamic and continuous optimization of the prediction results as data is updated. This ensures efficient and accurate data flow and processing from the data access unit to the physical field reconstruction unit.
[0063] S106. Constructing a global buffer for physical field data and an interface with a physical field reconstruction unit:
[0064] Build the data output architecture for the AI model. Once the data is processed and extracted, initiate the outbound transmission process. Develop a data transmission program that includes data dimensionality reconstruction and encapsulation based on the global cache access specification for physical field data.
[0065] S107. Constructing an HTTP service unit and an interface with the global cache of physical field data:
[0066] After receiving the HTTP service unit's information request, the global physics data cache performs a data format conversion operation. This converts the physics data into a binary stream to meet the system's internal data transmission requirements. After the conversion is complete, the physics reconstruction unit passes the binary stream data to the HTTP service unit. S2. Constructing the event control bus in the front-end visualization module specifically includes:
[0067] S201. Create a Vue framework:
[0068] A front-end framework based on the MVVM (Model-View-ViewModel) pattern that implements front-end development through data binding, event handling, and component systems. The core of the MVVM model is to divide the application into three main parts: Model, View, and ViewModel. Create multiple components under the Vue project, each of which is responsible for a specific function. Divide the page HTML into multiple different areas, each corresponding to a component, and each component has its own Model, View, and ViewModel to implement the basic functions of the front-end web page. For example, the parameter monitoring component is responsible for displaying the various parameters of the device, and the 3D component is responsible for 3D model rendering, visualizing the temperature field, and adjusting the model view scale.
[0069] S202, introduce the event center:
[0070] Create an event hub named store.js in the Vue.js project and import it into five components: the 3D physics rendering component, the 2D physics rendering component, the statistics rendering component, the alarm component, and the control center component. Store.js serves as the shared event hub for all components. All components can send and receive events to and from this hub through the Store.$on and Store.$emit events. This allows the bus to notify other components in parallel, providing a loosely coupled event communication mechanism.
[0071] S203, constructing a data acquisition unit:
[0072] In data monitoring, two-dimensional and three-dimensional components send APIs through HTTP service requests to build data acquisition units that send GET requests to the back-end server. The back-end server receives the GET request sent by the front-end, processes the request data and interacts with the database. After the processing is completed, the back-end returns the result to the front-end in the form of an HTTP response. After receiving the data returned by the back-end, the front-end updates the data, stores the data in the component model, and updates the front-end web page to display various data parameters of the device.
[0073] S204. Build the control center components, including:
[0074] 1) Build a rendering end event monitoring system
[0075] A rendering status flag object is defined in the index.vue component to track the rendering status of the three subcomponents (monitoring data, 2D, and 3D). Through lifecycle hooks, the index.vue component will continuously listen for rendering status signals sent by the three components via the bus after being mounted. When a rendering completion signal is received, the corresponding rendering status flag in the rendering status flag object will be set to 1.
[0076] 2) Build a system to monitor rendering status changes
[0077] In index.vue, use watch to monitor changes in the render status flag object. When the sum of the three render status flags is 3, it means that all three components have been rendered. At this point, the render status flag is reset and a function is called to send a request to the backend server to check the backend status.
[0078] 3) Embed a backend status check system into the response system
[0079] The Index.vue component sends a GET request to the backend server using the fetch API. The backend server receives the GET request, checks the backend calculation status, and returns the result to the frontend in the form of an HTTP response. If the backend returns a status of True, indicating that the calculation is complete, the ComputeEnd event is triggered through the event bus; otherwise, the user is prompted to wait or check the backend connection.
[0080] 4) Adding a physical field data request system to the response system
[0081] Through the mounted lifecycle hook, data monitoring, 2D, and 3D components monitor the bus for ComputeEnd events after they are mounted. Upon receiving a trigger event from the bus, the component calls the fetchData function and the fetch API to send a GET request to the backend server, retrieving and updating data from the backend. This enables a high-frequency loop for rendering tasks.
[0082] S3, build the rendering unit in the front-end visualization module, such as Figure 4 As shown, specifically including:
[0083] S301, data source acquisition:
[0084] After the user selects the required physical field information through the front-end interface, each rendering component is mounted and executed. The rendering data request component in each rendering component sends a request to the back-end to obtain the corresponding data, accesses the back-end program to obtain the AI prediction results, and the back-end returns the binary data stream corresponding to the obtained three-dimensional array to realize one-dimensional storage of the data.
[0085] S302, convert the binary data stream into an array:
[0086] Create a binary data stream decoder in the rendering component, read data from the data stream according to the 32-bit floating-point number type set by the backend, and convert the binary data stream into an array form to facilitate subsequent rendering calls.
[0087] S303. Create a data topology structure:
[0088] Predetermine the data field size based on user needs. Set the data dimension and sampling interval based on the data field size and required resolution. Also, set the origin coordinates and determine the topology of the received data. The sampling interval setting acts as a filter on the raw data, directly affecting rendering speed and accuracy.
[0089] S304. Import data:
[0090] The rendering component creates a data interface and imports the corresponding data of the sampling point coordinates into the core rendering component in preparation for rendering.
[0091] S305, core rendering process:
[0092] After data is imported, the core rendering component sequentially calls the mapper, renderer, and interactor to create a render window. The mapper extracts the data to be rendered from the data source and maps the processed data into a graphical representation. The renderer draws objects into the render window and manages the scene's background color, lighting, camera, and other aspects. After completing the renderer setup, the component adds the renderer to the render view. The render window interactor handles user input, allowing the user to interact with the rendered physics field, such as rotating and scaling.
[0093] S306: Associating a color scheme button with a different color scheme switch ensures that the new color scheme is maintained for each update after the color scheme is switched. After the user changes the color scheme, the color state of the color palette in the core rendering component is changed in real time, so that the new color scheme is used at the beginning of the next rendering round.
[0094] S307: Associating the slider position of the 2D section position with the slice mapper position to ensure that the slice position always uses the latest slider position during the real-time update of the 2D section. The monitoring component monitors the position slider information in real time. When the user drags the slider, the mapper setting is changed to change the rendered slice.
[0095] S308: Associating a transparency slider or input box with the transparency value of the 3D graphics renderer, and maintaining the transparency value entered by the user during the 3D graphics update. After the user modifies the transparency value attribute using the slider or input box, the opacity of the renderer in the rendering component is reset to ensure that the transparency of the 3D graphics remains consistent with the set value.
[0096] S309: Associating the physical field key location statistical information with the 3D graphics rendering function allows real-time physical field key locations to be rendered in the 3D graphics. The rendering component requests the physical field data, obtains the physical field key locations, sets the physical field key locations based on the received location coordinates, connects the output port of the physical field key location data source to the mapper, and sets the mapper to the renderer object to display the physical field key locations.
[0097] S310, associate the physical field selection button, each rendering component requests the corresponding field quantity data from the backend according to the physical field selected by the user and creates a topological structure to import it into rendering, avoiding the user interface jamming problem caused by rendering multiple physical field effects at the same time and optimizing the user experience.
[0098] S311. Associating the position of a 2D graphic slice with the 3D graphic to achieve a 3D rendering effect for the slice, and maintaining the position of the slice in the 3D graphic as it changes with the slice slider. After the user selects a 2D slice for display in the 3D image, the monitoring component transmits the position change information of the 2D slice to the 3D rendering component, which then changes the mapper settings to enable the display of the 2D slice in the 3D graphic.
[0099] It will be easily understood by those skilled in the art that the above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.
Claims
1. A low-latency, quasi-real-time digital twin visualization system, characterized by: It includes a front-end visualization module and a back-end digital physical field generation module, including: The front-end visualization module includes a rendering unit and an event control bus, wherein the rendering unit includes multiple rendering components for rendering physical field data into images; the event control bus includes a control center component and an event center, the control center component is used to monitor the rendering status of each rendering component, and the event center is shared by the control center component and the rendering component and is used to realize communication between the control center component and each rendering component; The back-end digital physical field generation module includes a data access unit, a physical field reconstruction unit, a global cache area and an HTTP service unit, wherein the data access unit is used to obtain measurement point data from the distributed control system in real time; the physical field reconstruction unit is embedded with an AI model, which is used to obtain physical field data based on the measurement point data; the global cache area is used to store physical field data in real time; the HTTP service unit is used to receive HTTP requests from the control center component and send the physical field data in the global cache area to the rendering unit.
2. The low-latency, quasi-real-time digital twin visualization system according to claim 1, characterized in that: The physical field reconstruction unit includes an AI model and an analysis model, wherein the AI model is used to reconstruct the physical field according to the measurement point data, and the analysis model is used to obtain physical field statistical information according to the reconstructed physical field analysis.
3. The low-latency, quasi-real-time digital twin visualization system according to claim 2, characterized in that: The rendering unit includes a three-dimensional physical field rendering component, a two-dimensional physical field rendering component and a statistical information rendering component. The three-dimensional physical field rendering component and the two-dimensional physical field rendering component are used to render and display the three-dimensional physical field and the two-dimensional physical field according to the reconstructed physical field. The statistical information rendering component is used to render and display statistical information according to the physical field statistical information.
4. The low-latency, quasi-real-time digital twin visualization system according to claim 3, wherein: The rendering unit further includes an alarm component, which is used to display alarm information when over-threshold statistical information appears in the statistical information rendering component.
5. The low-latency, quasi-real-time digital twin visualization system according to claim 1, wherein: The tasks of the physical field reconstruction unit are executed in an unconditional loop mode.
6. The low-latency, quasi-real-time digital twin visualization system according to claim 1, wherein: The physical field reconstruction unit and HTTP service unit tasks are deployed in a dual-threaded task mode.
7. The low-latency, quasi-real-time digital twin visualization system according to any one of claims 1 to 6, characterized in that: Each rendering component in the rendering unit adopts the vtk.js rendering pipeline.
8. A digital twin visualization method based on the low-latency quasi-real-time digital twin visualization system according to any one of claims 1 to 7, characterized in that: The steps include: The data access unit obtains the measurement point data from the distributed control system in real time, and the physical field reconstruction unit obtains the physical field data based on the measurement point data and stores the physical field data in the global cache in real time; When accessing the server, the control center component sends a rendering start event to the event center. The rendering unit receives the rendering start event via the event center. The rendering unit sends an HTTP request to the HTTP service unit to obtain the physical field data in the global cache. Each rendering component schedules the client GPU to render the physical field data into an image. After each rendering component completes rendering, the rendering unit broadcasts the rendering completion information to the event control bus, triggering the control center component to request to start the next rendering.
9. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the digital twin visualization method according to claim 8 is implemented.
10. A computer program product, characterized in that It includes a computer program, which, when executed by a processor, implements the digital twin visualization method as claimed in claim 8.