Graph flow data compression and recovery method and system based on compressed sensing theory

Abstract

The invention belongs to the field of network flow measurement and network data processing, and relates to a graph flow data compression and recovery method and system based on a compressed sensing theory. The method comprises the following steps: establishing a multi-layer structure for storing and compressing graph stream data; when the graph stream data arrives, executing a layer-by-layer insertion process by utilizing a multi-layer structure to realize compression storage of the graph stream data; performing query operation on the compressed and stored graph stream data, wherein the query operation comprises edge query, subsequent query and predecessor query; and decompressing the compressed and stored graph stream data to realize recovery of the graph stream data. Layered architecture design is adopted, efficient compression and accurate recovery of graph stream data are achieved through an ingenious coding mode and optimization solution, and efficient precursor and subsequent weight and query under constant complexity are supported.

Description

Technical Field

[0001] This invention relates to the fields of network traffic measurement and network data processing, specifically to a method and system for compressing and restoring graph flow data based on compressed sensing theory, which is suitable for achieving accurate compression and querying of high-speed graph flow data under limited resource constraints. Background Technology

[0002] With the continuous expansion of network scale and the increasing complexity of business operations, graph flow data processing plays a crucial role in various fields such as network measurement, social network analysis, and cloud computing fault diagnosis. Graph flow data is a continuous data sequence, where each data entry contains information such as the source node, target node, and edge weights. These data collectively constitute a dynamically changing graph structure. In practical applications, graph flow data has the following characteristics: High speed: In large data center scenarios, the bandwidth of core switches has reached 3.2Tbps or even higher, which means that millions of edge updates are generated every second.

[0003] Sparsity: Although the number of possible node pairs in the graph is huge (e.g., 2^64 possibilities for a tuple <source IP, destination IP>), the number of actually active edges is relatively small, exhibiting a highly sparse characteristic.

[0004] Dynamism: The structure of the graph changes continuously with the arrival of each new piece of data, requiring real-time processing and updates.

[0005] Currently, the mainstream image flow processing solutions mainly fall into two categories: The first type is sampling-based solutions. These solutions sample the data stream using a preset sampling ratio and send the sampled data to the control plane for recovery and analysis. However, due to the performance limitations of the control plane in receiving data packets (typically 2 million packets per second), this type of solution is difficult to handle high-speed graph streaming scenarios.

[0006] The second category is Sketch-based solutions. These solutions maintain a compact data structure on the data plane to record graph information. Representative works include CountMin Sketch and gSketch. However, existing Sketch solutions have the following shortcomings: Limited accuracy: Although these schemes provide theoretical error limits, in practice only a small number of flows (such as HeavyHitter) can achieve high accuracy, while the statistical accuracy of a large number of small flows is very poor.

[0007] Functionality limitations: Some Sketch solutions (such as CountMin and gSketch) do not support graph topology-related queries, such as reachability queries and successor queries.

[0008] High resource consumption: To ensure accuracy, existing solutions often require a large amount of storage space, which contradicts the limited resource constraints of switches.

[0009] Furthermore, existing traffic measurement schemes based on compressed sensing theory are mainly designed for specific scenarios such as traffic matrices or network tomography, lacking effective support for general-purpose graph flow data. Therefore, how to accurately compress and query high-speed graph flow data under limited resource constraints is a critical problem that urgently needs to be solved. Summary of the Invention

[0010] To address the challenge of accurately compressing and querying high-speed graph flow data under limited resource constraints, this invention provides a method and system for graph flow data compression and recovery based on compressed sensing theory.

[0011] The objective of this invention is achieved through the following technical solution: A method for compressing and restoring graph flow data based on compressed sensing theory includes the following steps: Establish a multi-layered structure for storing and compressing graph stream data; When the graph data arrives, a layer-by-layer insertion process is performed using a multi-layer structure to achieve compressed storage of the graph data; Perform query operations on compressed graph flow data, including edge queries, successor queries, and predecessor queries; Decompress the compressed image stream data to restore it.

[0012] Furthermore, each layer of the multi-layer structure consists of multiple blocks of the same size, and each block contains several counters used to count the weights of the edges. Each layer defines four key parameters: block_size represents the size of each block in the layer, fp_len represents the number of bits in the counters in the layer, combine_ratio represents the merging ratio between the layer and the next layer, and block_num represents the number of blocks in the layer. The 0th layer corresponds to the adjacency matrix form of the original graph flow data, and the remaining layers are divided into block_num blocks, each of which is a matrix of size (block_size, block_size).

[0013] Furthermore, the method of performing the layer-by-layer insertion process using a multi-layer structure includes: The graph flow data is mapped to multiple different positions in the i-th layer using hash_num hash functions. For each mapped position, the weight v of the edge is added to the corresponding counter. If the value of a counter exceeds 2^fp_len[i]-1, an overflow occurs, where fp_len[i] represents the number of bits of the counter in the i-th layer that is set in advance. At this time, the lower fp_len[i] bits are retained in the current layer, and the high-order bits of the overflow are recursively inserted into the (i+1)-th layer. That is, the overflow value is mapped to the hash_num positions in the (i+1)-th layer using a hash function, and the insertion operation is recursively performed again. The value inserted at each position is the quotient obtained by dividing the overflow value by 2^fp_len[i].

[0014] Furthermore, the edge query includes: given an edge between two nodes, finding the position of the edge mapped by the hash function at each layer, while recursively querying the upper layer to obtain the overflow value, and finally combining the query results of each layer to obtain the actual weight of the edge.

[0015] Furthermore, the subsequent query includes: scanning all positions of the row corresponding to the node, decompressing the corresponding weight for each position individually; summing all the weights to obtain the weight and result of the subsequent query; the predecessor query includes: scanning all positions of the column corresponding to the node, decompressing the corresponding weight for each position individually; summing all the weights to obtain the weight and result of the predecessor query.

[0016] Furthermore, the decompression includes single-point decompression; the single-point decompression includes: for the i-th layer, querying the weight of the (x, y) position of the j-th block; obtaining the value of the position mapped by hash_num hash functions in the (i+1)-th layer, taking the minimum value of it to obtain the overflow value at the current (x, y) position, adding the low-order value of the i-th layer to obtain the original value at the (x, y) position, and recursively querying to the top layer to end.

[0017] Furthermore, the decompression includes global decompression; the global decompression uses a top-down approach to restore the complete graph structure, restoring it layer by layer from the highest layer; for the i-th layer, a linear equation system is constructed using the counter value and hash mapping relationship of the (i+1)-th layer, where the variables of the equation system are the overflow values ​​at all overflow locations in the i-th layer, and the accurate overflow value at each location is obtained by solving the L1 norm minimization problem, and the process is recursively executed until the 1st layer, ultimately accurately restoring the original graph structure.

[0018] A graph flow data compression and recovery system based on compressed sensing theory, comprising: Multi-layer structure building module, used to create multi-layer structures for storing and compressing graph flow data; The insertion module is used to perform a layer-by-layer insertion process using a multi-layer structure when the graph flow data arrives, thereby achieving compressed storage of the graph flow data. The query module is used to perform query operations on the compressed and stored graph flow data, including edge query, successor query and predecessor query; The recovery module is used to decompress the compressed image stream data and restore it.

[0019] The beneficial effects of this invention are: This invention employs a layered architecture design, achieving efficient compression and accurate recovery of graph flow data through ingenious encoding methods and optimized solutions. In experimental scenarios, the memory space occupied by this invention's architecture is only about 1.13 times the number of edges, achieving compression with a space complexity ranging from quadratic to near-linear levels. Furthermore, in addition to simple graph flow compression and recovery, this invention's architecture also supports efficient predecessor, successor weight, and querying with constant complexity. Attached Figure Description

[0020] Figure 1 This is a flowchart of the steps of a graph flow data compression and recovery method based on compressed sensing theory according to the present invention.

[0021] Figure 2 This is an example diagram of a multi-layer structure for storing and compressing graph stream data according to the present invention.

[0022] Figure 3 This is an example graph for inserting graph flow data.

[0023] Figure 4 This is another example of graph flow data insertion.

[0024] Figure 5 This is an example image showing the result after inserting graph flow data.

[0025] Figure 6 This is an example graph for querying the sum of successor edge weights.

[0026] Figure 7 This is a module configuration diagram of a graph flow data compression and recovery system based on compressed sensing theory according to the present invention. Detailed Implementation

[0027] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the present invention will be further described in detail below with reference to specific embodiments and accompanying drawings.

[0028] This invention provides a method for compressing and restoring graph flow data based on compressed sensing theory. Compressed sensing theory states that as long as the signal is "compressible" (or sparse), it is possible to acquire the signal using a sampling rate far lower than that required by the traditional Nyquist sampling theorem, and to accurately reconstruct the original signal from these small amounts of sampled data.

[0029] This invention enables real-time insertion and deletion of graph flow data. The results of insertion and deletion are presented in compressed form and can be decompressed at any intermediate step. Furthermore, upon receiving a query request, the predecessor and successor weights of the queried node can be obtained in real time. The original, uncompressed graph flow data exists in the form of an adjacency matrix, which is a matrix where the number of rows and columns equals the number of nodes. A non-zero value v at (i, j) indicates that there is an edge with weight v from node i to node j.

[0030] Figure 1 This is a flowchart illustrating the steps of a graph flow data compression and recovery method based on compressed sensing theory according to the present invention. The method includes the following steps: Step S101: Establish a multi-layer structure for storing and compressing graph stream data.

[0031] This invention employs a multi-layered structure to store and compress graph flow data. Each layer consists of multiple blocks of the same size, and each block contains several counters used to calculate edge weights. To establish relationships between layers, four key parameters are defined for each layer: `block_size` represents the size of each block in that layer, `fp_len` represents the number of bits in the counters in that layer, `combine_ratio` represents the merging ratio between that layer and the next layer, and `block_num` represents the number of blocks in that layer. Layer 0 corresponds to the adjacency matrix form of the original graph flow data, and the remaining layers are divided into `block_num` blocks, each block being a matrix of size (`block_size`, `block_size`). Therefore, layer 0 can also be considered a structure where `block_num` is 1 and `block_size` is the number of nodes. Figure 2 This is an example of a multi-layered structure, illustrating a three-layered structure.

[0032] Step S102: When the graph flow data arrives, a layer-by-layer insertion process is performed using a multi-layer structure to achieve compressed storage of the graph flow data.

[0033] When a piece of graph flow data arrives, a layer-by-layer insertion process is performed. Suppose we want to insert an edge into the i-th layer, with a corresponding weight. An insertion can be represented as (x, y, v), meaning there's an edge with weight v from node x to node y. First, `hash_num` hash functions are used to map the graph flow data to multiple different positions in the i-th layer. For each mapped position, the edge weight, v, is added to the corresponding counter. If the value of a counter exceeds 2^fp_len[i] - 1, an overflow occurs, where `fp_len[i]` represents the pre-set number of counter bits in the i-th layer. At this point, the lower `fp_len[i]` bits are retained in the current layer, and the overflowing higher bits are recursively inserted into the (i+1)-th layer. Specifically, hash functions are used to map the overflow value to `hash_num` positions in the (i+1)-th layer, and the insertion operation is recursively performed again, with the inserted value at each position being the quotient of the overflow value divided by 2^fp_len[i]. This process continues until no more overflows occur or the highest layer is reached.

[0034] Step S103: Perform query operations on the compressed graph flow data, including edge query, successor query and predecessor query.

[0035] For query operations, this invention supports three basic graph operations: edge query, successor query, and predecessor query. In edge query, given an edge (s,d) between nodes s and d, the position of the edge mapped by the hash function is found at each layer. Simultaneously, the upper layers are recursively queried to obtain overflow values. Finally, the query results from each layer are combined to obtain the actual weight of the edge. In successor query, given a node v, the sum of the weights of all its outgoing edges needs to be calculated. To do this, all possible positions of the row corresponding to node v are found at each layer. For each position, possible overflow cases are recursively processed, and finally, the minimum value among all query results is returned as the final result. The process of predecessor query is similar to successor query, except that the position of the column corresponding to the node is found instead of the row position.

[0036] Specifically, the subsequent query includes the following steps: 1) Scan all positions in the row corresponding to node v, and decompress the corresponding weight for each position individually; 2) By summing all the weights, you can obtain the weights and results for subsequent queries.

[0037] Specifically, the predecessor query includes the following steps: 1) Scan all positions in the column corresponding to node v, and decompress the corresponding weight for each position individually; 2) By summing all the values, we can obtain the weights and results of the predecessor query.

[0038] Step S104: Decompress the compressed image flow data to restore the image flow data.

[0039] Both of the above queries use the core operation of decompression, which is further divided into single-point decompression and global decompression.

[0040] For single-point decompression, the multi-layer structure is queried recursively. Specifically, single-point decompression can be broken down into multiple independent query processes, defined as follows: for the i-th layer, query the weight of the (x, y) position of the j-th block. For this operation, since overflow occurs at the (x, y) position during insertion, the overflow result will be inserted into the (i+1)-th layer, it is necessary to obtain the values ​​mapped to the positions using hash_num hash functions in the (i+1)-th layer, take the minimum value of these values ​​to obtain the overflow value at the current (x, y) position, and add it to the low-order value of the i-th layer to obtain the original value at the (x, y) position. This is a recursive process; the query of the original adjacency matrix can actually be seen as a query of the 0th layer, which then calculates the result at the 1st layer, which in turn triggers a query at the 2nd layer, and so on until the top layer is reached.

[0041] For global decompression, this invention employs a top-down recovery method to restore the complete graph structure. Recovery begins at the highest level and proceeds layer by layer downwards. For the i-th level, a system of linear equations is constructed using the counter values ​​and hash mappings of the (i+1)-th level, where the variables are the overflow values ​​at all overflow locations within that i-th level. This problem can be transformed into an L1 norm minimization problem, and the precise overflow value at each location is obtained through optimization. By recursively executing this process up to the first level, the original graph structure can be accurately recovered.

[0042] In addition, for all query processes, a Bitmap or Bloom filter can be used to identify whether there is an overflow, enabling more accurate equation construction and faster queries.

[0043] The following is an embodiment of the present invention. In this embodiment, a graph flow consisting of 4 points is defined. The multi-layer structure proposed in this invention is used to compress the graph flow. It is assumed that layer 1 (first layer) has a block_num of 1, a block_size of 4, an fp_len of 2, and a combine_ratio of 1; layer 2 (second layer) has a block_num of 1, a block_size of 2, an fp_len of 2, and a total hash_num of 2. For example... Figure 2 As shown.

[0044] 1) Now insert (1, 2, 3), that is, there is an edge with a weight of 3 from node 1 to node 2.

[0045] like Figure 3 As shown, layer 0 is the actual adjacency matrix, which needs to be mapped to two positions in layer 1 using a hash function. Let's assume the selected position is... Figure 3 At the position pointed to by the middle arrow, since 3 does not exceed the maximum range that fp_len can represent with 2, no overflow occurs at this point, and the insertion ends.

[0046] 2) Now insert (2, 3, 2), that is, there is an edge with a weight of 2 from node 2 to node 3.

[0047] The actual adjacency matrix needs to be increased by 2. A hash function is used to select two locations in layer 1. Let's assume the selected locations are... Figure 4 At the location indicated by the middle arrow, one position normally adds 2. The red number represents the sum of the two additions: 3 + 2 = 5. Since fp_len of 2 can only represent up to 3, an overflow occurs. The overflow value needs to be further inserted into layer 2. 5 can be represented as 1 + (1 << 2), so layer 1 retains 1. Layer 2 needs to use a hash function to select two positions to insert 1. The final image result is as follows. Figure 5 As shown.

[0048] 3) Considering the query process, since predecessor query and successor query are basically inverse operations, this embodiment only considers how to query the weight sum of successor edges.

[0049] Now, let's look up the sum of the successor edge weights for 1. In the adjacency matrix, this is the sum of all values ​​in the row corresponding to 1. For this example, we'll only consider how the value 3 is obtained. First, we query in layer 1, finding the two positions marked by dashed lines. These two positions then need to be recursively queried in layer 2. We won't show how the dashed lines corresponding to the value 3 are queried here. For 5 (stored as 1 in layer 1), we need to query two positions in layer 2, calculating the overflow result 4 (1 in layer 2 represents 4 in layer 1). Adding this to the value stored in layer 1 gives us 5. Taking the minimum value of 3 and 5 gives the correct sum of the successor edge weights, 3. For example... Figure 6 As shown.

[0050] 4) Consider how to recover the entire adjacency matrix.

[0051] By recovering layer by layer in reverse, layer 1 is recovered one by one. Layer 2 does not need to be recovered. Consider how to use layer 2 to recover layer 1. Each number in layer 2 corresponds to some cells in layer 1. Assume that these cells in layer 1 are (x1, y1), (x2, y2), … (xn, yn). The overflow value is represented by overflow. The number in layer 2 is Z. Then overflow (x1, y1) + overflow (x2, y2) + … + overflow (xn, yn) = Z. After obtaining all the equations, we can use optimization methods to find all the overflow values ​​in layer 1.

[0052] In this example, one of the equations is overflow(2, 2) + overflow(...) = 4, where (2, 2) is the part that is known to have overflowed, so it is used here as an example. overflow(...) represents the overflow value of other layer 1 cells that are also mapped to the same cell in layer 2 by the same hash function.

[0053] The graph flow data compression and recovery method of the present invention can be applied to fields such as network measurement, social network analysis, and cloud computing fault diagnosis.

[0054] For example, one embodiment of the present invention provides a network measurement method for measuring real-time traffic matrices in large-scale data centers or backbone networks. Specifically, the method of the present invention compresses and stores graph flow data in a high-speed network, consisting of <source IP, destination IP> pairs as edges and traffic size as weights, in real time at the switch data plane. Then, at the control plane, the complete traffic matrix is ​​recovered by decompression, or a "successor query" is performed directly on the compressed structure to obtain the total outbound traffic of any IP, or a "precursor query" is performed to obtain the total inbound traffic, thereby obtaining the final network measurement result. Under the constraint of limited SRAM resources in the switch, the method of the present invention can achieve near-linear space overhead and high-precision real-time monitoring of the entire network traffic.

[0055] For example, one embodiment of the present invention provides a social network analysis method for analyzing real-time topic dissemination and user influence on large social platforms (such as Twitter and Weibo). Specifically, the method of the present invention efficiently compresses and distributes the dynamic graph flow data composed of user behaviors such as following, forwarding, and commenting in social networks. Then, through "successor queries," the potential dissemination range (out-degree weight sum) of a user is calculated in real time, or through "precursor queries," the source of influence of a hot topic is traced (in-degree weight sum), ultimately obtaining real-time user influence rankings and information dissemination path graphs. This solves the problems of high costs caused by full storage of massive social graph data in existing technologies, or the inability of traditional Sketch solutions to support complex topology queries, enabling low-cost, high-precision real-time insight into network dynamics and key nodes.

[0056] Another embodiment of the present invention provides a graph stream data compression and recovery system based on compressed sensing theory, such as... Figure 7 As shown, it includes: Multi-layer structure building module 201 is used to establish a multi-layer structure for storing and compressing graph flow data; The insertion module 202 is used to perform a layer-by-layer insertion process using a multi-layer structure when the graph flow data arrives, thereby achieving compressed storage of the graph flow data. The query module 203 is used to perform query operations on the compressed and stored graph flow data, including edge query, successor query and predecessor query; The recovery module 204 is used to decompress the compressed image flow data and restore the image flow data.

[0057] The above division of modules is merely illustrative. In practical applications, the functions described above can be assigned to different functional modules as needed to complete all or part of the functions described in the aforementioned method. The specific working process of each module can be found in the corresponding process in the aforementioned method embodiments, and will not be repeated here.

[0058] It should be understood that the methods and systems disclosed in the above embodiments of the present invention can be implemented in other ways. For example, the above module division can be implemented in other ways, multiple modules can be combined or integrated into another system, or some features can be ignored or not executed. Each step and module in the present invention can be implemented in the form of software functional units and can be stored in a computer-readable storage medium, including several instructions to cause a computer device to execute some or all of the steps of the method described in the present invention. For example, one embodiment of the present invention provides a computer device (computer, server, smartphone, etc.) including a memory and a processor, the memory storing a computer program configured to be executed by the processor, the computer program including instructions for executing each step of the method of the present invention. For example, another embodiment of the present invention provides a computer-readable storage medium (such as ROM / RAM, disk, optical disk, etc.) storing a computer program, which, when executed by a computer, implements each step of the method of the present invention. For example, another embodiment of the present invention provides a computer program product including a computer program, which, when executed by a computer, implements the steps of the method of the present invention.

[0059] The specific embodiments of the present invention disclosed above are intended to help understand the content of the present invention and to implement it accordingly. Those skilled in the art will understand that various substitutions, changes, and modifications are possible without departing from the spirit and scope of the present invention. The present invention should not be limited to the content disclosed in the embodiments of this specification; the scope of protection of the present invention is defined by the claims.

Claims

1. A method for compressing and restoring graph flow data based on compressed sensing theory, characterized in that, Includes the following steps: Establish a multi-layered structure for storing and compressing graph stream data; When the graph data arrives, a layer-by-layer insertion process is performed using a multi-layer structure to achieve compressed storage of the graph data; Perform query operations on compressed graph flow data, including edge queries, successor queries, and predecessor queries; Decompress the compressed image stream data to restore it.

2. The method according to claim 1, characterized in that, Each layer of the multi-layer structure consists of multiple blocks of the same size. Each block contains several counters used to count the weights of the edges. Each layer defines four key parameters: block_size represents the size of each block in the layer, fp_len represents the number of bits in the counters in the layer, combine_ratio represents the merging ratio between the layer and the next layer, and block_num represents the number of blocks in the layer. The 0th layer corresponds to the adjacency matrix form of the original graph flow data, and the remaining layers are divided into block_num blocks, each of which is a matrix of size (block_size, block_size).

3. The method according to claim 1, characterized in that, The process of performing layer-by-layer insertion using a multi-layer structure includes: The graph flow data is mapped to multiple different positions in the i-th layer using hash_num hash functions. For each mapped position, the weight v of the edge is added to the corresponding counter. If the value of a counter exceeds 2^fp_len[i]-1, an overflow occurs, where fp_len[i] represents the number of bits of the counter in the i-th layer that is set in advance. At this time, the lower fp_len[i] bits are retained in the current layer, and the high-order bits of the overflow are recursively inserted into the (i+1)-th layer. That is, the overflow value is mapped to the hash_num positions in the (i+1)-th layer using a hash function, and the insertion operation is recursively performed again. The value inserted at each position is the quotient obtained by dividing the overflow value by 2^fp_len[i].

4. The method according to claim 1, characterized in that, The edge query includes: given an edge between two nodes, finding the position of the edge mapped by the hash function at each layer, while recursively querying the upper layer to obtain the overflow value, and finally combining the query results of each layer to obtain the actual weight of the edge.

5. The method according to claim 1, characterized in that, The successor query includes: scanning all positions in the row corresponding to the node, decompressing the corresponding weight for each position individually, and summing all the weights to obtain the weight and result of the successor query; the predecessor query includes: scanning all positions in the column corresponding to the node, decompressing the corresponding weight for each position individually, and summing all the weights to obtain the weight and result of the predecessor query.

6. The method according to claim 1, characterized in that, The decompression includes single-point decompression; the single-point decompression includes: for the i-th layer, querying the weight of the (x, y) position of the j-th block; obtaining the value of the position mapped by hash_num hash functions in the (i+1)-th layer, taking the minimum value of it, obtaining the overflow value at the current (x, y) position, adding the low-order value of the i-th layer, obtaining the original value at the (x, y) position, and recursively querying to the top layer to end.

7. The method according to claim 1, characterized in that, The decompression includes global decompression; the global decompression uses a top-down approach to restore the complete graph structure, starting from the highest layer and proceeding layer by layer downwards; for the i-th layer, a linear equation system is constructed using the counter value and hash mapping relationship of the (i+1)-th layer, where the variables of the equation system are the overflow values ​​at all overflow locations in the i-th layer, and the accurate overflow value at each location is obtained by solving the L1 norm minimization problem, and the process is recursively executed until the 1st layer, ultimately accurately restoring the original graph structure.

8. A graph flow data compression and recovery system based on compressed sensing theory, characterized in that, include: Multi-layer structure building module, used to create multi-layer structures for storing and compressing graph flow data; The insertion module is used to perform a layer-by-layer insertion process using a multi-layer structure when the graph flow data arrives, thereby achieving compressed storage of the graph flow data. The query module is used to perform query operations on the compressed and stored graph flow data, including edge query, successor query and predecessor query; The recovery module is used to decompress the compressed image stream data and restore it.

9. A computer device, characterized in that, It includes a memory and a processor, the memory storing a computer program configured to be executed by the processor, the computer program including instructions for performing the method of any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program, which, when executed by a computer, implements the method according to any one of claims 1 to 7.

Images