A real-time interactive AR linkage method and system for real scene superimposed visualization

Abstract

The application provides a real-time interactive AR linkage method and system for real scene superimposed visualization, which comprises the following steps: listening to the dashboard interaction event, generating an interaction analysis semantic vector and an object mapping key; finding a candidate object set by using the object mapping key, combining the semantic vector and the adjacent hierarchical distance to calculate the object score and convert it into an analysis weight, and generating a target real scene object set; reading the old state intensity and the adjacent mean value, calculating the new state intensity based on the first-order recursion and the neighborhood difference, generating an object activation mark and screening an activated object set accordingly; constructing a request to obtain index data for the activated object, mapping the new state intensity into a superimposed display intensity factor, and rendering the superimposed content in the AR scene. The application realizes the dynamic association and smooth transition of virtual and real objects through the state evolution mechanism, accurately screens the target object according to the interaction intention and loads the data in real time, and effectively improves the real-time performance, continuity and interaction experience of data visualization in the AR scene.

Description

Technical Field

[0001] This invention belongs to the field of augmented reality, and in particular relates to a real-time interactive AR linkage method and system for overlaying and visualizing real scenes. Background Technology

[0002] As augmented reality and data visualization are increasingly applied in industrial operations and maintenance, smart parks, urban management, and exhibitions, the correlation between dashboard-based business data and real-world equipment, areas, and facilities has become a crucial method for on-site perception and rapid decision-making. Existing systems typically present metrics through visualization components and then overlay labels or graphics onto the real-world scene to achieve a "dashboard-real-world" comparison. At the interaction level, it's also common to see interactive methods where clicking on chart elements highlights real-world objects, pops up labels, or displays additional information. However, these interactions are often based on fixed correspondences or simple event mappings. When faced with dynamic configurations of display dimensions, layout structures, and interaction logic by users, mapping mismatches can easily occur. When users continuously click on different dashboard elements, frequently switch metrics, or drill down, the real-world side often responds with immediate display control, lacking continuous management of object states, leading to issues such as residual highlights, display conflicts, inconsistent label overlays, and asynchrony between data display and object emphasis. On the other hand, real-scene overlay has spatial continuity requirements. The emphasis on real-scene objects and the overlay of information need to remain consistent in space and time; otherwise, it will burden the user's understanding of the current analytical focus and related objects. Therefore, under the conditions of supporting variable dashboard configuration and high-frequency interaction, how to stably transmit the analytical semantics of a single interaction to the entire process of real-scene object selection, object emphasis intensity allocation, continuous object state updates, and drill-down result overlay display, while maintaining consistency between the virtual and real in continuous interaction, is a key problem that current technologies still struggle to address. Summary of the Invention

[0003] The purpose of this invention is to design a real-time interactive AR linkage method and system for real-scene overlay visualization, which can maintain a consistent, coherent and easy-to-understand presentation effect for dashboard interaction, real-scene object highlighting, label overlay and drill-down display under dynamic configuration and high-frequency operation.

[0004] To achieve the above objectives, a real-time interactive AR linkage method for real-scene overlay visualization is provided in a first aspect of the present invention, the method comprising:

[0005] S1: Listen for dashboard interaction events and obtain interaction event data and current visualization configuration data;

[0006] Based on the interactive event data and the current visualization configuration data, an interactive analysis semantic vector and an object mapping key are generated. The object mapping key is formed by concatenating the dimension field name and the dimension value.

[0007] S2: Use the object mapping key to search for a set of candidate objects in the real-world object registry, and combine the interactive analysis semantic vector and the pre-stored adjacency level distance to calculate the object score of each candidate object. Then, convert the object score into analysis weight through exponential normalization to generate the target real-world object set and analysis weight mapping.

[0008] S3: Read the old state strength of each real object in the target real object set and the average old state strength of the adjacent object set, calculate the new state strength based on the first-order recursive formula and the neighborhood difference term, and write the new state strength back to the cache.

[0009] Based on the comparison result between the new state intensity and the preset threshold, an object activation marker is generated, and a set of activated objects is selected.

[0010] S4: For each object in the set of activated objects, construct data request parameters and send a data request to obtain indicator data;

[0011] The new state intensity is linearly mapped to an overlay display intensity factor, and the overlay content is rendered in the AR real scene using the index data and the overlay display intensity factor.

[0012] Furthermore, the generation of interactive analysis semantic vectors and object mapping keys includes:

[0013] Extract the data item sequence number, data series number, and dimension value from the interactive event data; extract the dimension field name and total number of data items from the current visualization configuration data.

[0014] The sum of the proportion item and the series differentiation item is calculated using preset constant coefficients, the data item number, the total number of data items, and the data series number to obtain the interactive analysis semantic vector;

[0015] The object mapping key is obtained by concatenating the dimension field name and the dimension value into a string according to a preset format.

[0016] Further, the calculation of the object score for each candidate object includes:

[0017] Extract the integer part of the interaction analysis semantic vector to remove the influence of series intervals and retain the proportional semantic components;

[0018] Read the adjacency distance between the candidate object and the current dimension's main anchor point;

[0019] The object score is obtained by multiplying the proportional semantic component by the first adjustment coefficient and then adding the product of the second adjustment coefficient and the adjacent level distance decay function.

[0020] The adjacent level distance decay function decreases monotonically as the adjacent level distance increases.

[0021] Furthermore, the step of converting the object score into analytical weights through index normalization includes:

[0022] The object score of each candidate object in the candidate object set is subjected to an exponential operation to obtain an exponential score value;

[0023] Calculate the sum of the index scores of all candidate objects in the candidate object set to obtain the normalized denominator;

[0024] Divide the index score of each candidate object by the normalized denominator to obtain the corresponding analysis weight, so that the sum of the analysis weights of all candidate objects is 1.

[0025] Furthermore, the calculation of the new state strength includes:

[0026] Obtain the old state strength, analysis weight, and mean old state strength of the adjacent object set of the real-world object;

[0027] The difference between the analysis weight and the old state strength is calculated, and the difference is multiplied by the inertia coefficient to obtain the inertia adjustment term, wherein the inertia coefficient is a fixed value loaded by the system initialization configuration;

[0028] Calculate the difference between the mean old state strength and the old state strength of the set of adjacent objects, and multiply the difference by the neighborhood smoothing coefficient to obtain the neighborhood smoothing term, wherein the neighborhood smoothing coefficient is a fixed value loaded by the system initialization configuration;

[0029] The new state strength is obtained by adding the old state strength, the inertia adjustment term, and the neighborhood smoothing term.

[0030] Further, the generated object activation flag includes:

[0031] Define an indicator function. When the strength of the new state is greater than or equal to a preset threshold, the indicator function takes the value of 1; otherwise, it takes the value of 0.

[0032] The assignment result of the indicator function is used as the object activation flag and stored in the state table of the object node;

[0033] Only objects marked as 1 are included in the set of active objects.

[0034] Furthermore, the data request parameters include:

[0035] Parse the object mapping key to extract the dimension fields and their values;

[0036] Get the object identifier of the current object;

[0037] Query the pre-stored data interface mapping table for parameter templates that match the dimension field and dimension value;

[0038] The dimension field, the dimension value, and the object identifier are concatenated to form a complete data request parameter.

[0039] Further, the step of linearly mapping the new state intensity to a superimposed display intensity factor includes:

[0040] Obtain the proportional coefficient set during the system initialization phase;

[0041] Multiplying the new state intensity by the scaling factor yields the superposition display intensity factor;

[0042] The overlay display intensity factor is applied to control the transparency or size ratio of the overlay content.

[0043] Furthermore, the rendering and overlaying of content in the AR real-world scene includes:

[0044] Determine the data type of the acquired indicator. If it is a single-value indicator, render the text label component; if it is a time series array, render the embedded chart component.

[0045] Read the overlay display intensity factor and use it as a multiplier to adjust the brightness of the text label component or the transparency and size of the embedded chart component;

[0046] When the object activation flag changes from 1 to 0, data requests are stopped and the overlay display intensity factor is gradually reduced until the overlay content is removed.

[0047] In a second aspect, the present invention provides a real-time interactive AR linkage system for real-scene overlay visualization, the system comprising:

[0048] The interactive semantic generation module is used to listen to dashboard interactive events, obtain interactive event data and current visualization configuration data; and generate interactive analysis semantic vectors and object mapping keys based on the interactive event data and current visualization configuration data. The object mapping key is formed by concatenating dimension field names and dimension values.

[0049] The target weight analysis module is used to search for a set of candidate objects in the real-world object registry using the object mapping key, and calculate the object score of each candidate object by combining the interactive analysis semantic vector and the pre-stored adjacency level distance. The object score is then converted into analysis weights through exponential normalization processing to generate a target real-world object set and analysis weight mapping.

[0050] The state evolution and activation filtering module is used to read the old state intensity of each real object in the target real-scene object set and the average old state intensity of the adjacent object set, calculate the new state intensity based on the first-order recursive formula and the neighborhood difference term, and write the new state intensity back to the cache; generate object activation flags based on the comparison result of the new state intensity and the preset threshold, and filter out the set of activated objects.

[0051] The data drill-down and rendering module is used to construct data request parameters for each object in the set of activated objects and send data requests to obtain indicator data; linearly map the new state intensity to an overlay display intensity factor, and use the indicator data and the overlay display intensity factor to render the overlay content in the AR real scene.

[0052] The beneficial technical effects of the present invention are at least as follows:

[0053] To address the aforementioned issues, this invention provides a real-time interactive AR linkage method and system for real-scene overlay visualization. When an interaction occurs, the dashboard event is bound to the currently active configuration state as a structured semantic expression, generating mapping information that can be used for real-scene lookup, ensuring the interaction meaning remains consistent despite configuration changes. On the real-scene side, semantics are mapped to a set of target objects through a registry and spatial adjacency information. Multiple objects within the same dimension are assigned analytical weights for subsequent control, simultaneously determining "which object corresponds" and "to what degree of emphasis." Subsequently, the analytical weights drive the continuous evolution of object state intensity, combined with smoothing constraints of spatial neighborhood, ensuring a stable transition between highlighting and information hierarchy across multiple interactions, avoiding emphasis residue and screen jumps. During the display phase, data drilling and overlay rendering are performed with the object's active state as the boundary, unifying the drilling range, overlay content, and display intensity under real-scene state control, ensuring that the emphasis changes of real-scene objects are synchronized with data overlay. Through the above mechanism, this invention upgrades the traditional "event-triggered display" linkage method to a state-based linkage process oriented towards continuous interaction, so that dashboard interaction, real-scene object highlighting, label overlay and drill-down display maintain a consistent, coherent and easy-to-understand presentation effect under dynamic configuration and high-frequency operation. Attached Figure Description

[0054] The present invention will be further described with reference to the accompanying drawings, but the embodiments in the drawings do not constitute any limitation on the present invention. For those skilled in the art, other drawings can be obtained based on the following drawings without creative effort.

[0055] Figure 1 This is a flowchart of a real-time interactive AR linkage method for real-scene overlay visualization according to the present invention.

[0056] Figure 2This is a framework diagram of a real-time interactive AR linkage system for real-scene overlay visualization according to the present invention. Detailed Implementation

[0057] Embodiments of the present invention are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0058] In one or more embodiments, such as Figure 1 As shown, a real-time interactive AR linkage method for real-scene overlay visualization is disclosed, the method comprising the following:

[0059] S1: Listen for dashboard interaction events, obtain interaction event data and current visualization configuration data; generate interaction analysis semantic vectors and object mapping keys based on the interaction event data and current visualization configuration data, wherein the object mapping key is formed by concatenating dimension field names and dimension values;

[0060] Specifically, this step transforms a user interaction on the ECharts dashboard into a structured semantic expression that can directly participate in AR real-world interaction. Since the dashboard supports user-defined display dimensions and layout structures, the same chart element can represent different business meanings under different configurations. Therefore, the system synchronously binds the interaction event with the currently valid configuration at the moment the interaction occurs, generating an interaction analysis semantic vector. And generate object mapping keys for finding real-world objects. These two outputs will serve as the input basis for subsequent real-world object state control and data overlay display.

[0061] The system registers an interaction listener interface with the ECharts instance in the browser frontend, for example, by listening for click events using the `on('click', handler)` method. When a user clicks a chart element, the ECharts callback function returns a parameter object `params`, which contains the data series number `seriesIndex`, the data item number `dataIndex`, the value corresponding to the dimension name, and the current data value. Simultaneously, the system calls the `getOption()` interface of the current ECharts instance to obtain the currently active visualization configuration object, reading the current dimension field name, dimension array length, series structure, and encoding mapping from this object. The above interaction event data and configuration data are collected at the same time and form a complete interaction data input in the frontend logic layer memory.

[0062] After obtaining the interaction event data, semantic quantization processing is performed on it. Let the total number of data items in the current dimension be... Its value comes from the length of the corresponding data array in the configuration object returned by getOption(); let the index of the currently clicked data item be... Its value comes from params.dataIndex; let the current data series number be... Its value comes from params.seriesIndex; let A preset constant coefficient is used to distinguish the intervals of different data series in the semantic space. This constant is written into the front-end configuration file during system initialization. Interactive analysis of semantic vectors. Calculated using the following expression:

[0063] ;

[0064] in, This indicates the ordinal number of the current data item within its dimension. This indicates the total number of data items under this dimension. This indicates the series number to which the current data belongs. The constant coefficients, This is the calculated semantic vector for interaction analysis. (Proportional term) Map the position of data in the current dimension to a ratio value between 0 and 1, so that dimension sets of different sizes can be expressed on the same semantic scale; Used to distinguish different data series and ensure that semantic expressions do not overlap when multiple series coexist.

[0065] After completing the semantic vector calculation, the system generates object mapping keys. The specific steps are as follows: Read the current dimension field name (e.g., "Region") from `getOption()`; read the current dimension value (e.g., "Three Zones") from `params.name`; concatenate the two strings according to the format "Dimension Field: Dimension Value" to form... For example, when the dimension field is "Region" and the dimension value is "Three Zones", the generated... =“Region: Zone 3”. During the system deployment phase, AR reality objects have already established attribute identifiers corresponding to dimension fields and their values; therefore, subsequent steps can be performed using… Precise matching is performed on the set of real-world objects. Through the above processing, this step outputs an interaction analysis semantic vector. Object mapping key . Used for status determination and priority calculation in subsequent steps. Used to locate target objects in AR reality, the two together form a structured bridge between dashboard interaction and reality linkage.

[0066] S2: Use the object mapping key to search for a set of candidate objects in the real-world object registry, and combine the interactive analysis semantic vector and the pre-stored adjacency level distance to calculate the object score of each candidate object. Then, convert the object score into analysis weight through exponential normalization to generate the target real-world object set and analysis weight mapping.

[0067] Specifically, this step obtains the interactive analysis semantic vector in step one. Object mapping key Based on this, the abstract data semantics are transformed into "object set + analysis weights" that can be directly executed in AR real scene. As a semantic location primary key, it is used to search for a set of candidate objects in the real-world object registry. As a numerical semantic representation, it is used to characterize the relative position of this interaction within the current dimensional sequence and to distinguish series information. During the deployment phase, the system has already built a real-world object registry. This registry is exported by the scene editor as a structured data file (e.g., JSON structure), loaded into runtime memory, and its structure is a mapping from "dimensional field: dimension value" to an array of object identifiers. At runtime... As a key, a set of candidate objects is retrieved from the registry. Each element It serves as an identifier for objects registered in the AR engine, enabling direct location via engine APIs (such as Unity's Find or WebGL scene node indexes).

[0068] In obtaining the candidate object set Next, it is necessary to determine the importance of each object in the current analysis context based on the interaction semantics and object space structure. Here, two types of quantitative information are used: one type comes from the output of step one. Its proportion of components This indicates the relative position of the current click within this dimension; another type comes from the object's adjacency hierarchy distance in the scene. This distance is calculated during the scene editing phase based on the shortest path hierarchy between object anchor points and stored in the object registry. The decay form of the adjacency distance originates from the concept of hierarchy decay in discrete graph theory, that is, the influence of a node on the central node decreases as the hierarchy increases. A common expression is... Form. Combining the two types of information above, construct the object scoring function:

[0069] ;

[0070] in, Candidate object identifier, sourced from ; The semantic vector for interaction analysis obtained in step one; for The integer part is used to strip away the influence of series intervals, retaining only the proportional semantics; The adjustment coefficient is set in the configuration file during system initialization; For object The adjacent hierarchy distance to the current dimension's main anchor point is derived from a pre-stored value in the registry. This is used to calculate the object score. The first term in the expression characterizes the semantic strength of the data, and the second term characterizes spatial adjacency decay. Equivalent to The linear transformation form makes when The space-time term takes its maximum value, as... The value increases monotonically and decreases continuously, which facilitates subsequent normalization processing.

[0071] To transform the scores into weight allocations that can be directly used for state control, an exponential normalization method is employed. This method amplifies the differences in scores exponentially before summing and normalizing the total weights of all objects to a value of 1. The calculation method is as follows:

[0072] ;

[0073] in, Representation Object Analysis weights; For exponentiation; For candidate set Any object in; This is the score calculated by the previous formula. This expression maps the scores of each object to non-negative weights and normalizes them by summing the denominators, so that the sum of the weights of all candidate objects is 1, thus forming a proportional value that can be directly used for subsequent allocation of highlight intensity, label level, or data overlay priority.

[0074] The main anchor object receives the highest weight, while objects with greater proximity receive relatively lower weights, with the proportional differences being smooth and continuous. Finally, this step outputs a set of target real-world objects. Its corresponding analytical weight mapping When the candidate set contains only a single object, That is, the object and The value is 1; when multiple objects are contained, Includes all candidate objects. This serves as a mapping structure from objects to weights for subsequent steps. By combining the proportional components of interactive semantics with spatial adjacency decay and forming a stable weight distribution through exponential normalization, this step achieves a continuous mapping from "dashboard semantics" to "real-world object analysis targets," providing a directly executable structured basis for subsequent state transitions and AR overlay displays.

[0075] S3: Read the old state intensity of each real-world object in the target real-world object set and the average old state intensity of the adjacent object set, calculate the new state intensity based on the first-order recursive formula and the neighborhood difference term, and write the new state intensity back to the cache; generate object activation markers based on the comparison result of the new state intensity and the preset threshold, and filter out the set of activated objects;

[0076] Specifically, this step takes the set of target real-world objects output from step two. Weight mapping with object analysis This involves updating the object state that the AR engine can execute, ensuring a stable transition in the real-world representation during multiple dashboard interactions. In implementation, the system maintains a state intensity cache for each real-world object node on the AR engine side, with the object identifier as the cache key. The cached value is denoted as Object identifier Directly from Therefore, this step only applies to The inner object is updated. (Adjacent object collection) Scene registration data exported during the deployment phase (synchronously written to object records by the scene editor when saving the scene) can be loaded at runtime and queried by object identifier; the system reads this data during updates. The old state strengths of each object in the adjacency set are averaged to obtain... This is used to emphasize the background space surrounding an object. Because... It is the ratio value obtained by normalization in step two. and It is also maintained within the same proportional domain (by using same-domain initialization during the first write to the cache and continuing to update recursively), so subsequent items can be combined and operated on within the same numerical domain.

[0077] The object state intensity update adopts a discrete-time first-order recursive form, based on the first-order IIR smoothing commonly used in signal processing and control (which can also be understood as a discrete recursive expression of exponential smoothing): the new state is obtained by a weighted combination of the old state and the current input. To emphasize the continuity of objects within the same spatial cluster, the Laplace smoothing concept from the graph structure is introduced: the object state is pulled back to its neighborhood mean, commonly in the form of a difference term of "neighborhood mean minus itself". Combining the two and superimposing them linearly yields the update formula of this application, specifically by adding a neighborhood difference term to the first-order recursion and adjusting its influence with coefficients, thus forming a state evolution that is "smooth in time and continuous in space".

[0078] ;

[0079] in, The identifier for the real-world object is taken from the input set. ; For object The old state strength is read from the state cache of the AR engine object node; Analyze the weights of the objects output from step two, and then analyze them from the weight mapping table. Index reading; For object Adjacency set The mean strength of the old state, by traversing Read each adjacent object And calculate the average to obtain; The inertia coefficient is loaded during system initialization configuration. The neighborhood smoothing coefficient is loaded by the system initialization configuration. The updated state strength is then written back to the cache. This formula is derived from two links: the first-order recursive part... The exponential smoothing corresponds to "converging the old state into the current weight input"; neighborhood difference part This corresponds to Laplacian smoothing, which "pulls the object back to its neighboring background." After the two parts are linearly superimposed, the state change has both cross-interaction continuity and spatial continuity, making it suitable for scenarios with frequent dashboard interactions and where stable representation of the real scene is required.

[0080] To enable the next step to trigger label highlighting and data drill-down over a defined set of objects, this step will continuously adjust the state intensity. Convert to object activation tag The basis of this transformation is the classic threshold determination (which can also be seen as the application of indicator functions or step functions in discrete determination). The threshold divides continuous intensity into two categories: "requiring overlay display" and "maintaining background state," facilitating the direct implementation of subsequent actions.

[0081] ;

[0082] in, For object The activation flag is stored in a boolean field or status table of the object node; This is an indicator function; it takes the value 1 if the condition inside the parentheses is true, and 0 otherwise. Updated result from the previous formula; This is a threshold parameter, loaded by the system initialization configuration. Continuing with the numerical example above, if we take... ,but , , The system will then proceed to the next step based on this information. The object's tag highlighting is overlaid with the drill-down results, and the results are displayed. The object maintains background representation, thus keeping the image layers clear during continuous interaction.

[0083] This step outputs two items: the updated object state strength map. (A cache table with object identifiers as keys) and object activation tag mapping (A Boolean / binary table with object identifier as the key). Directly used to drive the AR engine's rendering properties. It is directly used in the next step to determine the scope of objects that need to be labeled and trigger data drilling. Together, they realize the "real scene analysis target" in step two into "a stable AR real scene state".

[0084] S4: For each object in the set of activated objects, construct data request parameters and send a data request to obtain indicator data; linearly map the new state intensity to an overlay display intensity factor, and use the indicator data and the overlay display intensity factor to render the overlay content in the AR real scene.

[0085] Specifically, this step involves mapping the object state intensity output in step three. Mapping with object activation marker Based on this, state-constrained data drill-down and AR real-scene overlay display are performed. Step three has already updated the analysis weights by recursively updating the model. Transformation into continuous state intensity The activation marker is obtained through a threshold function. Therefore, this step directly uses... The object is used as the display scope, so that the data drill-down and overlay behavior is strictly consistent with the current real-world analysis status.

[0086] The system first iterates through the collection of objects. (This set originates from step two and is used for state updates in step three), filtering to meet the requirements. The objects form the currently active object set. Then for each Construct the data request parameters. The data request parameters consist of two parts: the first part is the object mapping key generated in step one. The corresponding dimension fields and their values; the second part is the object identifier. During the deployment phase, the system establishes a data interface mapping table, which maps "dimension field: dimension value" to the parameter templates of the backend interface. At runtime, this is achieved through... The template is retrieved from the mapping table, and the object identifier is set. The request is constructed by concatenating additional fields, for example, {dimension: "region", value: "three zones", objectID: o}. The request is sent to the backend service via HTTP or WebSocket interface, and the backend returns the metric data for that object in the current dimension.

[0087] To ensure that the visual intensity of the overlaid data matches the intensity of the real-world state, this step employs a linear scaling mapping to adjust the state intensity. Mapped to overlay display intensity factor Linear mapping originates from the basic mathematical model of interval scaling, namely... A proportional relationship in the form of a dimensionless scale value is used to map a display control range. The mapping formula is:

[0088] ;

[0089] in, For object The superposition of intensity factors is displayed; The state strength after step three update; The scaling factor set for the system initialization phase. and Both are dimensionless proportional values, so the dimensions on the left and right sides are consistent.

[0090] To demonstrate the operability of the calculation process, an example is given: Assume that step three yields a certain object. State strength System configuration ,but In the AR engine, Write rendering parameters, such as control factors for label transparency or chart scaling. When When the value is close to 1, the label is displayed at near maximum brightness; when... When the size is small (e.g., 0.2), the label is displayed with lower transparency or at a smaller scale.

[0091] During the data overlay phase, the system selects the corresponding template for rendering based on the data type returned by the backend. If the returned value is a single-value indicator, the numerical value is written to the text label component; if the returned value is a time series array, an embedded small chart component (such as a mini line chart based on ECharts) is called for rendering. During rendering, As a multiplier between chart transparency and size ratio, objects with higher weighting are displayed with more complete chart information, while objects with lower weighting are displayed with simplified information. Through this... The directly related proportional mapping ensures that the data display and the highlight of the real scene maintain the same intensity.

[0092] When the user clicks on different dashboard elements consecutively, step three updates. This will gradually converge towards the new analytical weights; in this step... This also changes accordingly, causing the intensity of the overlay display to change synchronously with the state of the real-world object. If an object in a new interaction... If the value changes from 1 to 0, the system will stop requesting data for that object in the next frame and gradually reduce its value in the rendering layer. Control the display intensity until it is removed. Because Completely by Calculations show that the data display startup and fade-out process is consistent with the real-world status update process, thus achieving synchronous linkage between data display and real-world status.

[0093] The final output of this step is a collection of objects that have been overlaid and displayed in the AR real-world scene. and its corresponding superposition intensity mapping . Activation marker derived from step three , Derived from state strength The proportional mapping calculation is performed. Through the above calculation and rendering process, the data drill-down results generated by the dashboard interaction are accurately superimposed on the corresponding real-world objects, and their display intensity is consistent with the current analysis state of the objects.

[0094] In one or more embodiments, such as Figure 2 As shown, a real-time interactive AR linkage system for overlaying and visualizing real-scene scenes is disclosed. The system includes:

[0095] The interactive semantic generation module is used to listen to dashboard interactive events, obtain interactive event data and current visualization configuration data; and generate interactive analysis semantic vectors and object mapping keys based on the interactive event data and current visualization configuration data. The object mapping key is formed by concatenating dimension field names and dimension values.

[0096] The target weight analysis module is used to search for a set of candidate objects in the real-world object registry using the object mapping key, and calculate the object score of each candidate object by combining the interactive analysis semantic vector and the pre-stored adjacency level distance. The object score is then converted into analysis weights through exponential normalization processing to generate a target real-world object set and analysis weight mapping.

[0097] The state evolution and activation filtering module is used to read the old state intensity of each real object in the target real-scene object set and the average old state intensity of the adjacent object set, calculate the new state intensity based on the first-order recursive formula and the neighborhood difference term, and write the new state intensity back to the cache; generate object activation flags based on the comparison result of the new state intensity and the preset threshold, and filter out the set of activated objects.

[0098] The data drill-down and rendering module is used to construct data request parameters for each object in the set of activated objects and send data requests to obtain indicator data; linearly map the new state intensity to an overlay display intensity factor, and use the indicator data and the overlay display intensity factor to render the overlay content in the AR real scene.

[0099] It is worth noting that the specific workflow of the real-time interactive AR linkage system with real-scene overlay visualization provided in this embodiment of the invention is the same as that of the real-time interactive AR linkage method with real-scene overlay visualization described in the above embodiment, and will not be repeated here.

[0100] This invention also provides a real-time interactive AR linkage device for real-scene overlay visualization, including a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor. When the processor executes the computer program, it implements the steps described in the above embodiment of a real-time interactive AR linkage method for real-scene overlay visualization, for example... Figure 1 The steps S1 to S4 described above; or, when the processor executes the computer program, it implements the functions of each module in the above system embodiments.

[0101] For example, the computer program may be divided into one or more modules, which are stored in the memory and executed by the processor to complete the present invention. The one or more modules may be a series of computer program instruction segments capable of performing specific functions, which describe the execution process of the computer program in the real-time interactive AR linkage device for real-scene overlay visualization.

[0102] The aforementioned real-time interactive AR linkage device with real-scene overlay visualization can be a computing device such as a desktop computer, laptop, handheld computer, or cloud server. This device may include, but is not limited to, a processor and memory. Those skilled in the art will understand that the device may also include input / output devices, network access devices, buses, etc.

[0103] The processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor. The processor is the control center of the real-time interactive AR linkage device with real-scene overlay visualization, connecting all parts of the device via various interfaces and lines.

[0104] The memory can be used to store the computer program and / or modules. The processor, by running or executing the computer program and / or modules stored in the memory, and by calling the data stored in the memory, realizes various functions of the real-time interactive AR linkage device with real-scene overlay visualization. The memory may mainly include a program storage area and a data storage area. The program storage area may store the operating system, at least one application program required for a function, etc.; the data storage area may store data created based on the operation of the air conditioner controller, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as hard disk, memory, plug-in hard disk, smart media card (SMC), secure digital card (SD card), flash card, at least one disk storage device, flash memory device, or other volatile solid-state storage devices.

[0105] The module integrated into the real-time interactive AR linkage device for real-scene overlay visualization, if implemented as a software functional unit and sold or used as an independent product, can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the above embodiments of the present invention can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium, etc.

[0106] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0107] The above description represents the preferred embodiments of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications are also considered to be within the scope of protection of the present invention.

Claims

1. A real-time interactive AR linkage method for overlaying and visualizing real-scene data, characterized in that, The method includes: S1: Listen for dashboard interaction events and obtain interaction event data and current visualization configuration data; Based on the interactive event data and the current visualization configuration data, an interactive analysis semantic vector and an object mapping key are generated. The object mapping key is formed by concatenating the dimension field name and the dimension value. S2: Use the object mapping key to search for a set of candidate objects in the real-world object registry, and combine the interactive analysis semantic vector and the pre-stored adjacency level distance to calculate the object score of each candidate object. Then, convert the object score into analysis weight through exponential normalization to generate the target real-world object set and analysis weight mapping. S3: Read the old state intensity of each real-world object in the target real-world object set and the average old state intensity of the adjacent object set, calculate the new state intensity based on the first-order recursive formula and the neighborhood difference term, and write the new state intensity back to the cache; the calculation of the new state intensity includes: Obtain the old state strength, analysis weight, and mean old state strength of the adjacent object set of the real-world object; The difference between the analysis weight and the old state strength is calculated, and the difference is multiplied by the inertia coefficient to obtain the inertia adjustment term, wherein the inertia coefficient is a fixed value loaded by the system initialization configuration; Calculate the difference between the mean old state strength and the old state strength of the set of adjacent objects, and multiply the difference by the neighborhood smoothing coefficient to obtain the neighborhood smoothing term, wherein the neighborhood smoothing coefficient is a fixed value loaded by the system initialization configuration; The new state strength is obtained by adding the old state strength, the inertia adjustment term, and the neighborhood smoothing term. Based on the comparison result between the new state intensity and the preset threshold, an object activation marker is generated, and a set of activated objects is selected. S4: For each object in the set of activated objects, construct data request parameters and send a data request to obtain indicator data; The new state intensity is linearly mapped to an overlay display intensity factor, and the overlay content is rendered in the AR real scene using the index data and the overlay display intensity factor.

2. The real-time interactive AR linkage method according to claim 1, characterized in that, The generation of interactive analysis semantic vectors and object mapping keys includes: Extract the data item sequence number, data series number, and dimension value from the interactive event data; extract the dimension field name and total number of data items from the current visualization configuration data. The sum of the proportion item and the series differentiation item is calculated using preset constant coefficients, the data item number, the total number of data items, and the data series number to obtain the interactive analysis semantic vector; The object mapping key is obtained by concatenating the dimension field name and the dimension value into a string according to a preset format.

3. The real-time interactive AR linkage method according to claim 1, characterized in that, The calculation of the object score for each candidate object includes: Extract the integer part of the interaction analysis semantic vector to remove the influence of series intervals and retain the proportional semantic components; Read the adjacency distance between the candidate object and the current dimension's main anchor point; The object score is obtained by multiplying the proportional semantic component by the first adjustment coefficient and then adding the product of the second adjustment coefficient and the adjacent level distance decay function. The adjacent level distance decay function decreases monotonically as the adjacent level distance increases.

4. The real-time interactive AR linkage method according to claim 1, characterized in that, The process of converting the object score into analytical weights through index normalization includes: The object score of each candidate object in the candidate object set is subjected to an exponential operation to obtain an exponential score value; Calculate the sum of the index scores of all candidate objects in the candidate object set to obtain the normalized denominator; Divide the index score of each candidate object by the normalized denominator to obtain the corresponding analysis weight, so that the sum of the analysis weights of all candidate objects is 1.

5. The real-time interactive AR linkage method according to claim 1, characterized in that, The generated object activation flag includes: Define an indicator function. When the strength of the new state is greater than or equal to a preset threshold, the indicator function takes the value of 1; otherwise, it takes the value of 0. The assignment result of the indicator function is used as the object activation flag and stored in the state table of the object node; Only objects marked as 1 are included in the set of active objects.

6. The real-time interactive AR linkage method according to claim 1, characterized in that, The data request parameters include: Parse the object mapping key to extract the dimension fields and their values; Get the object identifier of the current object; Query the pre-stored data interface mapping table for parameter templates that match the dimension field and dimension value; The dimension field, the dimension value, and the object identifier are concatenated to form a complete data request parameter.

7. The real-time interactive AR linkage method according to claim 1, characterized in that, The step of linearly mapping the new state intensity to a superimposed display intensity factor includes: Obtain the proportional coefficient set during the system initialization phase; Multiplying the new state intensity by the scaling factor yields the superposition display intensity factor; The overlay display intensity factor is applied to control the transparency or size ratio of the overlay content.

8. The real-time interactive AR linkage method according to claim 1, characterized in that, The rendering and overlaying of content in AR real-world scenes includes: Determine the data type of the acquired indicator. If it is a single-value indicator, render the text label component; if it is a time series array, render the embedded chart component. Read the overlay display intensity factor and use it as a multiplier to adjust the brightness of the text label component or the transparency and size of the embedded chart component; When the object activation flag changes from 1 to 0, data requests are stopped and the overlay display intensity factor is gradually reduced until the overlay content is removed.

9. A real-time interactive AR linkage system for overlaying and visualizing real-scene scenes, characterized in that, The system includes: The interactive semantic generation module is used to listen to dashboard interactive events, obtain interactive event data and current visualization configuration data; and generate interactive analysis semantic vectors and object mapping keys based on the interactive event data and current visualization configuration data. The object mapping key is formed by concatenating dimension field names and dimension values. The target weight analysis module is used to search for a set of candidate objects in the real-world object registry using the object mapping key, and calculate the object score of each candidate object by combining the interactive analysis semantic vector and the pre-stored adjacency level distance. The object score is then converted into analysis weights through exponential normalization processing to generate a target real-world object set and analysis weight mapping. The state evolution and activation filtering module is used to read the old state intensity of each real-world object in the target real-world object set and the average old state intensity of the adjacent object set, calculate the new state intensity based on the first-order recursive formula and the neighborhood difference term, and write the new state intensity back to the cache; generate object activation tags based on the comparison result of the new state intensity and a preset threshold, and filter out the set of activated objects; the calculation of the new state intensity includes: Obtain the old state strength, analysis weight, and mean old state strength of the adjacent object set of the real-world object; The difference between the analysis weight and the old state strength is calculated, and the difference is multiplied by the inertia coefficient to obtain the inertia adjustment term, wherein the inertia coefficient is a fixed value loaded by the system initialization configuration; Calculate the difference between the mean old state strength and the old state strength of the set of adjacent objects, and multiply the difference by the neighborhood smoothing coefficient to obtain the neighborhood smoothing term, wherein the neighborhood smoothing coefficient is a fixed value loaded by the system initialization configuration; The new state strength is obtained by adding the old state strength, the inertia adjustment term, and the neighborhood smoothing term. The data drill-down and rendering module is used to construct data request parameters for each object in the set of activated objects and send data requests to obtain indicator data; linearly map the new state intensity to an overlay display intensity factor, and use the indicator data and the overlay display intensity factor to render the overlay content in the AR real scene.

Images