A method and system for progressive visualisation of time series data interactions

Abstract

The application provides a time series data interaction progressive visualization method and system, which converts original data into a hierarchical maximum-minimum tree structure representation mode by using maximum-minimum aggregation and difference operation; according to the visualization requirement, a target layer is selected from the maximum-minimum tree structure, and a breadth search is performed on the maximum-minimum tree structure from the layer; according to the time range relationship between the tree node and the column pixel, corresponding nodes and child nodes are traversed, and the obtained maximum-minimum tree structure is updated and visualized during the traversal process. The application combines the time series data representation mode based on the maximum-minimum tree structure and the incremental query visualization generation based on the tree structure, realizes the progressive generation of accurate visualization, and can provide various smooth interaction modes, and can effectively meet the demand of large-scale time series data interactive visualization.

Description

Technical Field

[0001] This invention belongs to the field of data visualization and data management technology, and relates to a progressive visualization method and system for time-series data interaction. Background Technology

[0002] The statements in this section are merely background information related to the present invention and do not necessarily constitute prior art.

[0003] Time-series data is widely used in fields such as finance, manufacturing, healthcare, and environmental monitoring, for example, in monitoring price changes, production line operation status, and medical equipment. Time-series data is collected by periodically measuring variables that change over time and then stored in a remote database on a cloud server. This allows data analysts to interactively explore and analyze the data using visualization tools on client-side applications. By interacting with time-series data visualized as line graphs, users can perform various analytical tasks to discover useful information hidden within the data, such as peaks, trends, and periodic changes. To improve the efficiency of time-series data analysis, many interactive visualization technologies have been developed, such as SignalLens, multi-focus zoom, Zenvisage, and other visualization query tools. These technologies help users better understand time-series data and discover interesting features within it.

[0004] However, according to the inventors, the scale of time-series data stored in remote databases is usually enormous. Directly visualizing the raw, large-scale time-series data on the client side presents two problems: (1) the large data size leads to long data transmission times; and (2) the client's limited memory makes it impossible to store the entire amount of data at once. These two problems are the fundamental reasons currently hindering people from exploring smooth interaction with large-scale time-series data.

[0005] A common method to reduce data transmission latency is to reduce the size of the transmitted data. Aggregation sampling is an effective way to reduce data size by sampling the data during the data acquisition phase. However, reducing the size of the data transmitted to the client may lead to errors in the visualization results. Currently, many techniques and methods have been proposed to address the loss of original data features after aggregation sampling. However, most methods do not consider that aggregation sampling can significantly affect the user's perception of the visualization results. For example, many existing techniques adjust the visualization results by squeezing or stretching after the user resizes the display window, resulting in distortion. To address this problem of visualization errors, the M4 time-series data aggregation method for visualization has been proposed. Within a given display window size, M4 can find the data records needed to accurately render each column of pixels, ensuring that the visualization results generated using the aggregated data are pixel-wise identical to those of the original data. However, in scenarios with large-scale time-series data, M4 cannot support smooth interactive exploration of the data by the user. First, because M4's query execution time complexity is O(n), where n is the length of the time series data, generating a visualization for data exceeding one million records would take more than one second, exceeding the time latency limit for interactive exploration (less than 500 milliseconds). Second, every time a user initiates an interaction while exploring time series data in M4, M4 needs to send a new data query request to the server. Due to these limitations, M4 cannot support continuous interactive operations, such as panning and zooming time ranges, and therefore is not suitable for visual analysis of large-scale time series data.

[0006] Progressive visualization is a classic method for visualizing large-scale data. Unlike traditional blocking methods that wait for query results, progressive visualization techniques can immediately present users with visualizations of intermediate results that they can interact with. IncVisage is an excellent example of a progressive visualization method that uses online sampling to progressively calculate intermediate features of the visualization, thus quickly presenting intermediate results of data analysis. This method can rapidly present approximate visualizations within seconds and continuously update existing results over time, ultimately obtaining accurate visualizations. However, each update in IncVisage requires a request for new results from the server, and its network transmission cost is linearly related to the number of updates. Due to these characteristics, IncVisage is difficult to apply to interactive visualization of large-scale time-series data. Summary of the Invention

[0007] To address the aforementioned problems, this invention proposes a progressive visualization method and system for time-series data interaction. This invention utilizes the Omni-Temporal Tree (OM) representation method for time-series data based on a max-min tree structure. 3 Combined with tree-based incremental query visualization generation, it achieves progressive generation of accurate visualizations and can provide a variety of smooth interaction methods, effectively meeting the needs of interactive visualization of large-scale time series data.

[0008] According to some embodiments, the present invention adopts the following technical solution:

[0009] A progressive visualization method for time-series data interaction includes the following steps:

[0010] The original data is transformed into a hierarchical max-min tree structure representation by using maximum and minimum value aggregation and difference operations.

[0011] Based on visualization requirements, a target layer is selected in the maximum-minimum tree structure, and a breadth-first search is performed on the maximum-minimum tree structure from that layer.

[0012] Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

[0013] As an alternative implementation, the maximum-minimum tree structure representation is structurally a complete binary tree, where each node stores two values, a maximum value and a minimum value, which are calculated from the values ​​stored in its two child nodes.

[0014] As an alternative implementation method, the specific process of converting the original data into a hierarchical max-min tree structure representation using maximum-min value aggregation and difference operations includes:

[0015] Query the original time-series data that needs to be encoded;

[0016] Fill in the missing data in the original time series data;

[0017] Calculate sorting coefficients to indicate the order and missing data.

[0018] The aggregation coefficient and detail coefficient are recursively calculated to reverse-engineer the original time series data.

[0019] Furthermore, the specific process for calculating the ranking coefficients includes:

[0020] When both adjacent data points are not missing, and the former is less than the latter, the sorting coefficient is set to (0, 0);

[0021] When both adjacent data points are not missing, and the former is greater than the latter, the sorting coefficient is set to (1, 1);

[0022] When the former is missing, the sorting coefficient is set to (0, 1);

[0023] When the latter is missing, the sorting coefficient is set to (1, 0);

[0024] When either of these two conditions is missing, the sorting coefficient is set to empty.

[0025] As an alternative implementation, the specific process of selecting the target layer in the maximum and minimum tree structure according to the visualization requirements includes selecting a certain layer in the tree structure based on the width w of the visualization window and the current time range to be visualized [t1, t2], wherein the number of nodes in the layer is just greater than w, and performing a breadth-first search on the tree structure from that layer.

[0026] As an alternative implementation, the specific process of traversing the corresponding nodes and child nodes based on the relationship between the time range of the tree nodes and the time range of the column pixels includes:

[0027] If the time range of a tree node completely falls within the time range of a certain column of pixels, then use that node to update the maximum and minimum values ​​of that column of pixels, and stop traversing the child nodes of that node.

[0028] If the time range of a tree node does not completely fall within the time range of a certain column of pixels, then it is necessary to continue visiting the child nodes of that node.

[0029] If the child node to be accessed does not exist in the tree structure, the data is requested again and the child node is reconstructed.

[0030] Furthermore, if the maximum and minimum values ​​stored in a node can be contained in the intersection of its left and right columns of pixels, then stop traversing the child nodes of that node.

[0031] As an alternative implementation, during the hierarchical traversal of the tree structure, the aggregation coefficients of the next level are constructed based on the detail coefficients, thereby constructing the entire coefficient tree, and the inverse transformation is performed to obtain the aggregation coefficients and insert them into the tree structure.

[0032] The visualization process involves dividing the time series data into w groups according to the time dimension, where w is the width of the screen space;

[0033] From each of the w sets of data, select the data points with the maximum value and the data points with the minimum value, resulting in a total of w maximum data points and w minimum data points;

[0034] Rasterize the pixels in column w using the maximum and minimum values;

[0035] Determine whether the range of data values ​​of the last data point in each group and the first data point in the next group is contained within the intersection of the maximum and minimum values ​​of the pixels in the preceding and following columns. If it is contained, then the last data point and the first data point in the next group are unwanted data; if they are not contained, then the last data point and the first data point in the next column need to be selected for user visualization.

[0036] A progressive visualization system for time-series data interaction, comprising:

[0037] The tree structure representation module is configured to transform the original data into a hierarchical max-min tree structure representation using maximum-minimum aggregation and difference operations.

[0038] The incremental query module is configured to select a target layer in the maximum-minimum tree structure according to visualization requirements, and perform a breadth-first search of the maximum-minimum tree structure from that layer.

[0039] Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

[0040] A progressive visualization system for time-series data interaction, comprising:

[0041] The server is configured to perform maximum and minimum value aggregation and difference operations to transform the raw data into a hierarchical maximum and minimum tree structure representation, store it, and respond to data interaction requests from clients.

[0042] The client is configured to send a data interaction request, select a target layer in the max-min tree structure according to visualization requirements, and perform a breadth-first search of the max-min tree structure from that layer.

[0043] Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

[0044] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0045] This invention transforms time-series data into an ordered, multi-level max-min tree structure representation. Compared with storing the original data directly in the database, this representation method greatly improves query efficiency and can save nearly 3 / 4 of the storage space.

[0046] The incremental query algorithm based on tree structure designed in this invention can quickly generate completely accurate visualization results for time series data of arbitrary length within a visualization window of arbitrary width.

[0047] The time-series data representation method and incremental query algorithm designed in this invention can support a variety of smooth interactive methods required for visual analysis of time-series data, which can greatly improve the work efficiency of data analysts.

[0048] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, preferred embodiments are described below in detail with reference to the accompanying drawings. Attached Figure Description

[0049] The accompanying drawings, which form part of this invention, are used to provide a further understanding of the invention. The illustrative embodiments of the invention and their descriptions are used to explain the invention and do not constitute an improper limitation of the invention.

[0050] Figure 1 This is an overall architecture diagram of an interactive visualization system for large-scale time-series data designed based on this invention.

[0051] Figure 2 This is a schematic diagram of the line segment aggregation model proposed in this invention to generate visualizations, where a is the visualization generated using the original data, b is the visualization generated based on the line segment aggregation model, and L1 is an unnecessary line segment that has no impact on the quality of the visualization result.

[0052] Figure 3 This is a schematic diagram illustrating how the original time-series data is encoded using an encoding algorithm in this invention, and how the time-series data is constructed based on a tree structure with a maximum and minimum multi-level representation.

[0053] Figure 4 This is a schematic diagram illustrating the use of incremental querying in this invention to traverse a tree structure and generate a visualization. In diagram a, the process of traversing the tree structure is shown; the nodes within the black dashed boxes are those ignored by the pruning strategy in this invention. Diagram b illustrates the gradual generation of visualization results by rasterizing screen pixels while traversing the tree structure. Diagram c illustrates the final, completely accurate visualization result generated using the tree structure and incremental query.

[0054] Figure 5 This is a schematic diagram illustrating the steps of offline encoding of raw time-series data based on the present invention.

[0055] Figure 6 This is a flowchart for generating visualizations through incremental queries of a tree structure based on this invention. Detailed Implementation

[0056] The present invention will be further described below with reference to the accompanying drawings and embodiments.

[0057] It should be noted that the following detailed description is illustrative and intended to provide further explanation of the invention. Unless otherwise specified, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains.

[0058] It should be noted that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the scope of exemplary embodiments according to the invention. As used herein, the singular form is intended to include the plural form as well, unless the context clearly indicates otherwise. Furthermore, it should be understood that when the terms "comprising" and / or "including" are used in this specification, they indicate the presence of features, steps, operations, devices, components, and / or combinations thereof.

[0059] This invention provides an interactive progressive visualization method for time-series data. This method significantly improves the speed of real-time data querying by encoding the original time-series data into a hierarchical max-min tree structure. Combined with the tree-based incremental query visualization generation method of this invention, it can generate accurate visualization results for time-series data of any scale within a window of arbitrary screen width, and offers a flexible and fast interactive experience.

[0060] The specific implementation of the present invention will be described below.

[0061] This invention comprises two important parts: first, converting time-series data into a tree-structured max-min representation; and second, generating incremental query visualizations.

[0062] First, we introduce the encoding method for converting time-series data into a tree-structured maximum-minimum representation. This encoding process uses maximum-minimum aggregation and difference operations to convert the original data into an Omnibus representation. 3 This indicates that, during the interaction, through OM... 3 This indicates that the inverse operation is performed to restore the original data, thereby ensuring the smoothness of the interaction.

[0063] Specifically, the following steps are included:

[0064] S101: Retrieve the original time-series data that needs to be encoded from the database. Typically, the queried data contains two fields: a time field and a numerical field corresponding to that time.

[0065] S102, Fill in null values ​​for the data. Since time-series data collected in the production environment may be missing, it is necessary to fill in the missing data before executing the encoding. Figure 3 The pink nodes at level 4 represent nodes filled with null values.

[0066] S103, Calculate the sorting coefficients. Since the data order needs to be identified during the data reconstruction process, sorting coefficients need to be calculated here. Each sorting coefficient contains two bits, used to mark the data order and missing data. The specific calculation steps are as follows:

[0067] S103-1, when both adjacent data points are not missing and the former is less than the latter, the sorting coefficient is set to (0, 0);

[0068] S103-2, when both adjacent data points are not missing and the former is greater than the latter, the sorting coefficient is set to (1, 1);

[0069] S103-3, when the predecessor is missing, the sorting coefficient is set to (0, 1);

[0070] S103-4, when the latter is missing, the sorting coefficient is set to (1, 0);

[0071] S103-5, when both are missing, the sorting coefficient is set to null;

[0072] S104, calculation of aggregation factor and detail factor, such as Figure 3 As shown, level 4 to level 0 is the process of calculating the aggregation coefficient and the detail coefficient. In each node, the top two numbers are the aggregation coefficient and the bottom two numbers are the detail coefficient. The yellow background represents the minimum aggregation coefficient and its corresponding detail coefficient, and the green background represents the maximum aggregation coefficient and its detail coefficient.

[0073] S105. Because we need aggregation coefficients and detail coefficients to reverse-engineer the original data when generating visualizations, we need to store the aggregation coefficients for level 0, as well as the detail coefficients for levels 0, 1, and 2, in the database. During the coding process, we adopted a method of storing the coefficients after each level is calculated.

[0074] S106, recursively calculate the aggregation coefficient and detail coefficient, such as Figure 3 As shown, since we are building a tree structure with a hierarchical structure, we need to recursively calculate S104-S105 until we reach level0.

[0075] The time-series data representation is structurally a complete binary tree. Each node in the tree stores two values, a maximum value and a minimum value, which are calculated from the values ​​stored in its two child nodes.

[0076] Using the above method, ordinary time-series data can be encoded into a time-series data representation based on a max-min tree structure, enabling lossless reconstruction of the original data. The encoding algorithm formulas are shown in Formulas 1-1 and 1-2, and the decoding algorithm is its inverse formula, shown in Formulas 2-1 and 2-2.

[0077]

[0078]

[0079]

[0080]

[0081] Where v is the data value of the time series data, i is the number of each data point after encoding, and j is the hierarchical number of the hierarchical structure. It is min(v); It is max(v); D j-1 It is the difference between adjacent data points.

[0082] The tree structure described above is stored on a server (or other host device). During the upload and storage process, the tree structure is "flattened" to facilitate storage. Therefore, when a user needs to perform data interaction visualization, the device first sends a request to the server to retrieve the data, rebuild the tree structure, and then executes the following incremental query visualization generation process.

[0083] The incremental query visualization generation process includes the following steps:

[0084] S201, Construct the initial tree structure. This step aims to build the highest levels of a complete binary tree. Figure 4 In view 'a', this step will build the three levels of the tree structure: level0, level1, and level2.

[0085] S202, based on the initial tree structure, constructs the maximum and minimum values ​​of each column of pixels, in Figure 4 The visualization uses a 3-column pixel-width window, so it starts from level 2 of the tree structure to build initial maximum and minimum value information for these three columns of pixels.

[0086] Based on the width w of the visualization window and the current time range [t1, t2] to be visualized, select a certain level in the tree structure. The number of nodes in this level is just greater than w. Perform a breadth-first search on the tree structure from this level.

[0087] If the time range of a tree node completely falls within the time range of a certain column of pixels, then use that node to update the maximum and minimum values ​​of that column of pixels, and stop traversing the child nodes of that node.

[0088] If the time range of a tree node does not completely fall within the time range of a certain column of pixels, then it is necessary to continue visiting the child nodes of that node. Furthermore, if the maximum and minimum values ​​stored in that node can be contained within the intersection of the pixels in its left and right columns, then traversing the child nodes of that node can be stopped.

[0089] If the child node to be accessed does not exist in the tree structure, the data is requested from the server and the child node is reconstructed.

[0090] At each level of the tree nodes, the collected maximum and minimum value data are used to update the visualization on the screen.

[0091] Specifically, in this embodiment:

[0092] S203, the level-order traversal tree structure continues to collect the maximum and minimum values ​​for each column of pixels. This process starts from level 3. At this point, the maximum and minimum values ​​of the first column of pixels are 12 and 20, respectively; the maximum and minimum values ​​of the second column are 6 and 29, respectively; and the maximum and minimum values ​​of the third column are 21 and 36, respectively. During subsequent breadth-order traversals of the tree structure, these maximum and minimum values ​​of the three columns of pixels will be continuously updated, because the deeper the tree, the greater the precision of the information.

[0093] S204, construct the visualization structure for the current level. During the hierarchical traversal, we can update the visualization results at each level, thus achieving progressive visualization. Figure 4 As shown in view b, the visualization is updated twice using the maximum and minimum value information of each column of pixels obtained from level 2 and level 3. Compared to the visualization based on level 2 information, the visualization based on level 3 information contains more detail and is therefore more accurate.

[0094] S205, Node pruning: During incremental queries, some nodes will span two columns of pixels (e.g., ...). Figure 4 The nodes in the frame of view A contain important information that we must continuously refine to make it more accurate. However, some nodes span two columns of pixels and contribute nothing to generating the final, completely accurate visualization structure. Therefore, query efficiency can be improved by prematurely terminating the traversal of these nodes. Figure 4In view 'a', the nodes enclosed by black dashed boxes are the pruned nodes. The pruning is possible because the maximum and minimum values ​​of its parent node are [14, 17], the maximum and minimum values ​​of the pixels in the preceding column are [7, 20], and the maximum and minimum values ​​of the pixels in the following column are [6, 29]. The intersection of the two columns is [7, 20], and [7, 20] completely contains [14, 17], so its child nodes do not need to be traversed.

[0095] S206, Detailed coefficients are retrieved from the server. During the level-order traversal of the tree structure, detailed coefficients are continuously retrieved from the server to construct the aggregate coefficients for the next level, thus building the entire coefficient tree. Figure 3 As shown, the bottom-up process is the forward encoding process, while the top-down process is the process of reconstructing the original data by obtaining detailed coefficients from the server during the traversal.

[0096] S207, Perform the inverse transformation to obtain the aggregation coefficients and insert them into the tree structure. Because during the level-order traversal, it cannot be guaranteed that the required data is already in the tree each time, if the required data does not exist on the current client, the corresponding detailed coefficients need to be obtained from the server, and then the aggregation coefficients are obtained by performing the inverse transformation and inserted into the tree structure.

[0097] S208, recursively execute S203-S207 until the tree traversal is complete. Since we are performing a level-order traversal of the tree structure until the last level of the tree or the traversal process ends prematurely due to node pruning, we need to perform all the steps of S203-S207 in a recursive manner.

[0098] The above process enables OM 3 It means that it can generate accurate visualization results in any size visualization window and has the ability to perform progressive visualization.

[0099] The line segment aggregation model is capable of generating fully accurate visualizations of time series data using minimal data. Figure 2 The image demonstrates how this model generates fully accurate time-series data visualizations. The model selects and visualizes data points following these steps:

[0100] 1. Divide the time series data into w groups according to the time dimension, where w is the width of the screen space.

[0101] 2. From each of the w sets of data, select the data points with the maximum value and the data points with the minimum value, resulting in a total of w maximum value data points and w minimum value data points.

[0102] 3. Rasterize the pixels in column w using the maximum and minimum values.

[0103] 4. Determine if the range of values ​​for the last data point in each group and the first data point in the next group is contained within the intersection of the maximum and minimum values ​​of the pixels in the preceding and following columns. If contained, then the last data point and the first data point in the next group are unnecessary data. If not contained, then the last data point and the first data point in the next column need to be selected for user visualization. Figure 2 In the diagram, L1 represents the two data points to be selected, while L2 represents the data points that are not needed.

[0104] The present invention provides the following product embodiments:

[0105] A progressive visualization system for time-series data interaction, comprising:

[0106] The server is configured to perform maximum and minimum value aggregation and difference operations to transform the raw data into a hierarchical maximum and minimum tree structure representation, store it, and respond to data interaction requests from clients.

[0107] The client is configured to send a data interaction request, select a target layer in the max-min tree structure according to visualization requirements, and perform a breadth-first search of the max-min tree structure from that layer.

[0108] Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

[0109] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0110] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1A device that provides the functions specified in one or more boxes.

[0111] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0112] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0113] The above description is merely a preferred embodiment of the present invention and is not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

[0114] While the specific embodiments of the present invention have been described above in conjunction with the accompanying drawings, this is not intended to limit the scope of protection of the present invention. Those skilled in the art should understand that various modifications or variations that can be made by those skilled in the art without creative effort based on the technical solutions of the present invention are still within the scope of protection of the present invention.

Claims

1. A progressive visualization method for time-series data interaction, characterized in that, Includes the following steps: The original data is transformed into a hierarchical max-min tree structure representation using maximum-minimum aggregation and difference operations. This includes: querying the original time-series data that needs to be encoded; filling in missing data in the original time-series data; calculating sorting coefficients to mark the order and missing data; and recursively calculating aggregation coefficients and detail coefficients to reverse-engineer the original time-series data. The max-min tree structure representation is structurally a complete binary tree, where each node stores two values, a maximum value and a minimum value, which are calculated from the values ​​stored in its two child nodes. Based on visualization requirements, a target layer is selected in the maximum-minimum tree structure, and a breadth-first search is performed on the maximum-minimum tree structure from that layer. Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

2. The progressive visualization method for time-series data interaction as described in claim 1, characterized in that, The specific process for calculating the ranking coefficient includes: When both adjacent data points are not missing, and the former is less than the latter, the sorting coefficient is set to (0, 0). When both adjacent data points are not missing, and the former is greater than the latter, the sorting coefficient is set to (1, 1). When the former is missing, the sorting coefficient is set to (0, 1); When the latter is missing, the sorting coefficient is set to (1, 0); When either of these two conditions is missing, the sorting coefficient is set to empty.

3. The progressive visualization method for time-series data interaction as described in claim 1, characterized in that, According to the visualization requirements, the specific process of selecting the target layer in the maximum and minimum tree structure includes selecting a certain layer in the tree structure based on the width w of the visualization window and the current time range [t1, t2] to be visualized, where the number of nodes in the layer is just greater than w, and performing a breadth-first search on the tree structure from that layer.

4. A progressive visualization method for time-series data interaction as described in claim 1 or 3, characterized in that, The specific process of traversing the corresponding nodes and child nodes based on the relationship between the time range of the tree nodes and the time range of the column pixels includes: If the time range of a tree node completely falls within the time range of a certain column of pixels, then use that node to update the maximum and minimum values ​​of that column of pixels, and stop traversing the child nodes of that node. If the time range of a tree node does not completely fall within the time range of a certain column of pixels, then it is necessary to continue visiting the child nodes of that node. If the child node to be accessed does not exist in the tree structure, the data is requested again and the child node is reconstructed. Alternatively, if the maximum and minimum values ​​stored in a node can be contained in the intersection of its left and right columns of pixels, stop traversing the child nodes of that node.

5. The progressive visualization method for time-series data interaction as described in claim 1, characterized in that, During the hierarchical traversal of the tree structure, the aggregate coefficients of the next level are constructed based on the detail coefficients, thereby constructing the entire coefficient tree. The inverse transformation is then performed to obtain the aggregate coefficients and insert them into the tree structure.

6. The progressive visualization method for time-series data interaction as described in claim 1, characterized in that, The visualization process involves dividing the time series data into w groups according to the time dimension, where w is the width of the screen space; From each of the w sets of data, select the data points with the maximum value and the data points with the minimum value, resulting in a total of w maximum data points and w minimum data points; Rasterize the pixels in column w using the maximum and minimum values; Determine whether the range of data values ​​of the last data point in each group and the first data point in the next group is contained within the intersection of the maximum and minimum values ​​of the pixels in the preceding and following columns. If it is contained, then the last data point and the first data point in the next group are unwanted data; if they are not contained, then the last data point and the first data point in the next column need to be selected for user visualization.

7. A progressive visualization system for time-series data interaction, characterized in that, include: The tree structure representation module is configured to convert the original data into a hierarchical max-min tree structure representation using maximum-minimum aggregation and difference operations. This includes: querying the original time-series data that needs to be encoded; filling in missing data in the original time-series data; calculating sorting coefficients to mark the order and missing data; and recursively calculating aggregation coefficients and detail coefficients to reverse-engineer the original time-series data. The max-min tree structure representation is structurally a complete binary tree, where each node stores two values: a maximum value and a minimum value, which are calculated from the values ​​stored in its two child nodes. The incremental query module is configured to select a target layer in the maximum-minimum tree structure according to visualization requirements, and perform a breadth-first search of the maximum-minimum tree structure from that layer. Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

8. A progressive visualization system for time-series data interaction, characterized in that, include: The server is configured to perform maximum and minimum value aggregation and difference operations to convert the original data into a hierarchical maximum-minimum tree structure representation and store it. It also responds to client data interaction requests, including: querying the original time-series data that needs to be encoded; filling in missing data in the original time-series data; calculating sorting coefficients to mark the order and missing data; and recursively calculating aggregation coefficients and detail coefficients to reverse-engineer the original time-series data. The maximum-minimum tree structure representation is structurally a complete binary tree, where each node stores two values: a maximum value and a minimum value, which are calculated from the values ​​stored in its two child nodes. The client is configured to send a data interaction request, select a target layer in the max-min tree structure according to visualization requirements, and perform a breadth-first search of the max-min tree structure from that layer. Based on the relationship between the time range of tree nodes and the time range of column pixels, the corresponding nodes and child nodes are traversed, and the obtained maximum and minimum tree structures are updated visually as the traversal process progresses.

Images