Method and apparatus for displaying large batch of dynamic targets based on polymerization depolymerization

Abstract

The application relates to a large-batch dynamic target hierarchical display method and device based on aggregation and disaggregation. The method comprises the following steps: initializing an update period of a buffer area, a buffer area boundary and a clustering level of a spatial network, accessing dynamic target data in real time, adding dynamic targets in the dynamic target data into different initialized buffer areas according to dynamic target position information in the dynamic target data, traversing all dynamic targets in the initialized buffer areas every time an update period is experienced, performing aggregation on each dynamic target, updating a buffer area hierarchical method and a spatial grid clustering level when a stable view window length exceeds a first update period, performing aggregation and disaggregation based on an existing initial target group set to obtain a target group set, and traversing all target groups in the target group set to refresh symbol drawing of each target group to obtain a dynamic target hierarchical display result. The method can improve dynamic target aggregation efficiency and precision.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to a method and apparatus for displaying large-scale dynamic target hierarchical structures based on aggregation and deaggregation. Background Technology

[0002] In situational geographic information systems, such as UAV reconnaissance systems or UAV-assisted disaster relief systems, symbols are typically used to visualize dynamic battlefield targets to assist commanders in obtaining real-time and accurate environmental situational information. On the one hand, as the amount of situational information increases, a large number of symbols may be displayed simultaneously within a map area, leading to overlapping, disorganization, and reduced rendering efficiency. On the other hand, to meet the needs of commanders to perceive environmental situations at different granularities, multi-layered representation of dynamic targets is required. Layered aggregation of dynamic targets—focusing on specific information when the viewport's geographical area is small, and on the overall distribution when the viewport's geographical area is large—can better meet both needs, improve the accuracy of command, and thus enhance the reconnaissance or disaster relief efficiency of UAVs.

[0003] Existing dynamic target aggregation algorithms are mainly divided into three categories: spatial grid-based aggregation, point distance-based aggregation, and grid distance-based aggregation. Spatial grid-based aggregation has the highest computational efficiency but a large aggregation error; distance-based aggregation has the highest accuracy but extremely low computational efficiency; grid distance-based aggregation has both computational efficiency and aggregation accuracy in between. Simultaneously improving aggregation efficiency and accuracy, while meeting the requirement of frequent updates to aggregation results due to real-time changes in dynamic targets, is the main challenge in displaying large-scale dynamic target aggregation. Summary of the Invention

[0004] Therefore, it is necessary to provide a method and apparatus for large-scale dynamic target hierarchical display based on aggregation and deaggregation, which can improve the efficiency and accuracy of dynamic target aggregation, in order to address the above-mentioned technical problems.

[0005] A method for hierarchical display of large batches of dynamic targets based on aggregation and deaggregation, the method comprising:

[0006] Obtain the buffer for dynamic target hierarchical display; initialize the buffer update cycle, buffer boundaries, and spatial network clustering level to obtain the initialized buffer;

[0007] The system receives dynamic target data in real time and adds the dynamic targets to different initialized buffers based on their location information. After each update cycle, it iterates through all the dynamic targets in the initialized buffers, aggregates each dynamic target, and obtains an initial target group set.

[0008] When the stable duration of the view window exceeds the first-level update cycle, the update buffer hierarchical method and spatial grid clustering level are updated, and aggregation and de-aggregation are performed based on the existing initial target group set to obtain the target group set;

[0009] Iterate through all target groups in the target group set, refresh the symbol drawing of each target group, and obtain the dynamic target layer display result.

[0010] In one embodiment, the update period of the buffer, the buffer boundaries, and the clustering level of the spatial network are initialized to obtain an initialized buffer, including:

[0011] Set the first-level update cycle and the second-level update cycle according to the pre-set real-time location display accuracy requirements of dynamic targets; set the classification boundaries of the first-level buffer and the second-level buffer according to the currently acquired geographic spatial range of the view window;

[0012] The collision radius is calculated based on the currently acquired view window map resolution and the size of the plotted symbols. The H3 spatial grid resolution table is then consulted, and the level with the largest average side length of the regular hexagon less than the collision radius is taken as the clustering level of the spatial grid.

[0013] In one embodiment, the collision radius is calculated based on the currently acquired view window map resolution and the size of the plotted symbols, including:

[0014] The collision radius is calculated based on the current viewport map resolution and the size of the plotted symbols.

[0015] radius = resolution * length / 2

[0016] Where resolution represents the resolution of the currently acquired view window map, and length represents the size of the plotted symbols.

[0017] In one embodiment, the method of real-time access to dynamic target data, adding dynamic targets to different initialized buffers based on the dynamic target location information in the dynamic target data, further includes:

[0018] Based on the location information of the dynamic targets in the dynamic target data, the dynamic targets are added to different initialized buffers. If the location information of the dynamic target is within the geographic space of the view window, the corresponding dynamic target is added to the first-level buffer. If the location information of the dynamic target is outside the geographic space of the view window, the corresponding dynamic target is added to the second-level buffer.

[0019] In one embodiment, if the location information of a dynamic target is within the geographic space of the view window, the corresponding dynamic target is added to the first-level buffer, and the method further includes:

[0020] If a dynamic target with the same ID exists in the first-level buffer, meaning that the dynamic target has been received in the current period, update the target (Cache) information and record the current position code target (Cache).code1 = code; where code1 represents the H3 spatial grid code of the latest position of the dynamic target, that is, the current position code code represents the H3 spatial grid code;

[0021] If no dynamic target with the same ID exists in the first-level buffer, but a dynamic target with the same ID, target(Set), exists in the dynamic target set (i.e., the target was not received in the current period but was received in a previous period), record the historical position code target(Rcv).code0 = target(Set).code1, and record the target group to which it belongs.

[0022] target(Rcv).group = target(Set).group, which adds target(Rcv) to the first-level buffer; where code0 represents the H3 spatial grid code of the position when the dynamic target is first added to the buffer, i.e., the historical position code, and group represents the target group identifier to which the dynamic target belongs;

[0023] If there is no dynamic target with the same ID in the first-level buffer, and there is no dynamic target with the same ID in the dynamic target set, that is, the dynamic target has not been received in the current period or in the historical period, the historical position code target(Rcv).code0 is recorded as empty, the target group to which it belongs is recorded as empty, and target(Rcv).group is added to the first-level buffer.

[0024] In one embodiment, each dynamic target is aggregated to obtain an initial target group set, including:

[0025] Step 1: Remove the current dynamic target from the buffer;

[0026] Step 2: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which the dynamic target belongs is empty, then aggregate the dynamic target;

[0027] Step 2.1: Add the dynamic target to the target group, extract the first 19 + (3*L) bits of the current position code of the dynamic target to form a prefix code, use the prefix code as an index to find the spatial grid to which the dynamic target belongs and the adjacent spatial grid, and search whether the target group exists in the grid; where L represents the spatial grid clustering level;

[0028] Step 2.1.1: If no target group exists in the spatial grid to which the dynamic target belongs or in the adjacent spatial grids, create a new target group, group, record the number of elements in the target group as group.num = 1, the target group location as group.location = target(Cache).location, and the target group location code as group.code = target(Cache).code1, add group to the target group set GroupSet; record the target group to which the dynamic target belongs as target(Cache).group = group;

[0029] Step 2.1.2: If there is only one target group (group) in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, add the dynamic target to the group and update the group information. The updated group information includes updating the target group location (group.location), updating the target group location code (group.code = code), updating the number of target group elements (group.num = group.num + 1), and recording the target group to which the dynamic target belongs (target(Cache).group = group).

[0030] Step 2.1.3: If multiple target groups exist in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, only temporarily deepen the grid clustering level in this process, that is, after setting the spatial grid clustering level L = L + 1, add the dynamic target to the target group, and extract the first 19 + (3 * L) bits of the current position code of the dynamic target to form a prefix code; use the prefix code as an index to find the spatial grid to which it belongs and the adjacent spatial grids, check whether there is a target group in the grid, and then execute step 2.1;

[0031] Step 2.2: Add the dynamic target to the dynamic target set;

[0032] Step 3: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which it belongs is not empty, remove the dynamic target from the original target group and aggregate the dynamic target. The aggregation process includes: obtaining the original target group group = target(Cache).group; removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the information of the original target group, including: updating the target group location group.location, updating the target group location code group.code = code, and updating the number of elements in the target group group.num = group.num-1; adding the dynamic target to the new target group.

[0033] The process of updating the target group location `group.location` is as follows: Convert the latitude and longitude coordinates of the target group location `group.location` to Cartesian coordinates x(group), y(group), z(group); convert the latitude and longitude coordinates of the dynamic target location `target(Cache).location` to Cartesian coordinates x(target), y(target), z(target); calculate the new Cartesian coordinates.

[0034] x(new)=(x(group)*group.num-x(target)) / (group.num-1);

[0035] y(new)=(y(group)*group.num-y(target)) / (group.num-1);

[0036] z(new)=(z(group)*group.num-z(target)) / (group.num-1);

[0037] Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form new location information location(new), and update the target group location group.location = location(new).

[0038] In one embodiment, updating the target group location group.location includes:

[0039] Convert the latitude and longitude coordinates of the target group location `group.location` to Cartesian coordinates `x(group), y(group), z(group)`; convert the latitude and longitude coordinates of the dynamic target location `target(Cache).location` to Cartesian coordinates `x(target), y(target), z(target)`; calculate the new Cartesian coordinates:

[0040] x(new)=(x(group)*group.num+x(target)) / (group.num+1);

[0041] y(new)=(y(group)*group.num+y(target)) / (group.num+1);

[0042] z(new)=(z(group)*group.num+z(target)) / (group.num+1);

[0043] Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form new location information location(new), and update the target group location group.location = location(new).

[0044] In one embodiment, when the stable duration of the viewport window exceeds the first-level update cycle, the update buffer hierarchy and spatial grid clustering level are used to perform aggregation and de-aggregation based on the existing initial target group set to obtain the target group set, including:

[0045] Step 4.1: When the stable duration of the viewport window exceeds the first-level update cycle, update the buffer hierarchy and spatial grid clustering level. Based on the existing initial target group set, perform aggregation and de-clustering. First, update the geospatial extent of the viewport window. Traverse all dynamic targets in the first-level buffer. If a dynamic target is outside the updated geospatial extent of the viewport window, move the dynamic target to the second-level buffer to obtain the updated second-level buffer. Traverse all dynamic targets in the second-level buffer. If a dynamic target is within the updated geospatial extent of the viewport window, move the dynamic target to the first-level buffer to obtain the updated first-level buffer.

[0046] Step 4.2: Reinitialize the spatial grid clustering layer. If the current spatial grid clustering level is larger than the previous spatial grid clustering level, then disaggregate the target groups. Iterate through all target groups in the initial target group set. For target groups whose location is within the updated view window's geographic space and whose number of dynamic targets is greater than 1, iterate through all dynamic targets in the target group and update the target group to which the dynamic target belongs. The update process includes: removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the original target group information, including: updating the target group location group.location, updating the target group location code group.code = code, and updating the number of elements in the target group group.num = group.num - 1; or adding the dynamic target to a new target group, as detailed in Step 2.1.

[0047] Step 4.3: If the current spatial grid clustering level is smaller than the spatial grid clustering level at the previous time step, then perform target group aggregation, including:

[0048] Step 4.3.1: Traverse all target groups in the initial target group set, remove target groups whose locations are within the geospatial range of the updated view window from the target group set, and add them to the temporary target group set;

[0049] Step 4.3.2: Traverse all target groups in the temporary target group set, and aggregate each target group, including:

[0050] Step 4.3.2.1: Extract the first 19 + (3*L) bits of the current position code of the target group group(old) to form a prefix code; using the prefix code as an index, find the spatial grid to which the target group belongs and the adjacent spatial grid, and check whether the target group exists in the grid. If the target group does not exist in the belonging spatial grid and the adjacent spatial grid, create a new target group group, record group.num = group(old).num, group.location = group(old).location, group.code = group(old).code, and add group to GroupSet; iterate through all dynamic targets in group(old), and further... Each dynamic target belongs to a target group named "group". If there is only one target group "group" in the target space grid and adjacent spatial grids, add "group(old)" to "group" and update the group information. The updated group information includes: updating the target group location "group.location", updating the target group location code "group.code = code", updating the number of target group elements "group.num = num", and updating the target group to which each dynamic target belongs to "group". If there are multiple target groups in the target space grid and adjacent spatial grids, only temporarily deepen the grid clustering level in this step, that is, set the spatial grid clustering level L = L + 1, and jump to step 4.3.2.1.

[0051] The update process for the target group location `group.location` includes: converting the latitude and longitude coordinates of `group.location` to Cartesian coordinates x(group), y(group), z(group); converting the latitude and longitude coordinates of `group(old).location` to Cartesian coordinates x(old), y(old), z(old); and calculating the new Cartesian coordinates.

[0052] num=group.num+group(old).num;

[0053] x(new)=(x(group)*group.num+x(old)*group(old).num) / num;

[0054] y(new)=(y(group)*group.num+y(old)*group(old).num) / num;

[0055] z(new)=(z(group)*group.num+z(old)*group(old).num) / num;

[0056] Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form the location information location(new), and record group.location = location(new).

[0057] In one embodiment, all target groups in the target group set are traversed, and the symbol rendering of each target group is refreshed to obtain a dynamic target layered display result, including:

[0058] Iterate through all target groups in the target group set. If the number of dynamic targets in a target group is 0, delete the target group drawing symbol and remove the target group from the target group set. If the target group is a newly added target group, create a new drawing symbol on the map, with the symbol position being the target group position, and mark the number of target group elements in the upper right corner of the symbol. If the target group is an existing target group, refresh the symbol position to the target group position, and refresh the number in the upper right corner of the symbol to show the number of target group elements.

[0059] A large-scale dynamic target hierarchical display device based on aggregation and deaggregation, the device comprising:

[0060] The initialization module is used to obtain the buffer for the hierarchical display of dynamic targets; it initializes the update period, buffer boundaries, and clustering level of the spatial network of the buffer to obtain the initialized buffer.

[0061] The aggregation module is used to access dynamic target data in real time. Based on the dynamic target location information in the dynamic target data, the dynamic targets are added to different initialized buffers. After each update cycle, all dynamic targets in the initialized buffers are traversed, and each dynamic target is aggregated to obtain an initial target group set.

[0062] The target group set aggregation and de-aggregation module is used to update the buffer hierarchy and spatial grid clustering level when the stable duration of the view window exceeds the first-level update cycle. It performs aggregation and de-aggregation based on the existing initial target group set to obtain the target group set.

[0063] The dynamic target layered display module is used to traverse all target groups in the target group set, refresh the symbol drawing of each target group, and obtain the dynamic target layered display result.

[0064] The aforementioned method and apparatus for hierarchical display of large batches of dynamic targets based on aggregation and de-aggregation, in this application, rapidly locates the spatial distribution of dynamic targets using H3 spatial grid coding and efficiently retrieves nearby target groups using coding indexes. While achieving accuracy close to that of distance-based clustering, it avoids a large amount of spatial geometric calculations. It also periodically updates the real-time state of dynamic targets through hierarchical caching, meeting user situational awareness requirements while reducing meaningless frequent updates to target group states. Furthermore, when the viewport window changes, aggregation and de-aggregation are performed based on existing target groups, saving computation time compared to aggregation and de-aggregation based on individual targets. Through these optimizations in aggregation calculation, the efficiency and accuracy of dynamic target aggregation are improved, achieving efficient rendering and display of large batches of dynamic targets. Attached Figure Description

[0065] Figure 1 This is a flowchart illustrating a method for displaying large batches of dynamic target hierarchical structures based on aggregation and deaggregation in one embodiment.

[0066] Figure 2 This is a structural block diagram of a mass dynamic target hierarchical display device based on aggregation and deaggregation in one embodiment;

[0067] Figure 3 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation

[0068] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0069] In one embodiment, such as Figure 1 As shown, a method for displaying large batches of dynamic target hierarchical structures based on aggregation and deaggregation is provided, including the following steps:

[0070] S1, obtain the buffer for dynamic target hierarchical display; initialize the buffer update cycle, buffer boundary and spatial network clustering level to obtain the initialized buffer;

[0071] By initializing the buffer and using a hierarchical buffer mechanism to handle dynamic targets that change in real time, meaningless frequent calculations are reduced. Using the H3 spatial grid as the basis for clustering and optimizing the square grid with a regular hexagonal grid can improve computational efficiency.

[0072] S2, real-time access to dynamic target data, dynamic targets are added to different initialized buffers according to the dynamic target location information in the dynamic target data. After each update cycle, all dynamic targets in the initialized buffers are traversed, and each dynamic target is aggregated to obtain the initial target group set.

[0073] During the aggregation of each dynamic target, the adjacent spatial grid is added to the clustering judgment to avoid dynamic targets at the grid edge being incorrectly clustered.

[0074] S3, when the stable duration of the view window exceeds the first-level update cycle, update the buffer hierarchical method and spatial grid clustering level, and perform aggregation and de-aggregation based on the existing initial target group set to obtain the target group set;

[0075] When transforming the view window, performing aggregation and deaggregation based on the existing target group saves computation time compared to performing aggregation and deaggregation based on the target, which can greatly improve computational efficiency.

[0076] S4 iterates through all target groups in the target group set, refreshes the symbol drawing of each target group, and obtains the dynamic target layer display result.

[0077] By optimizing the aggregation calculation of large batches of dynamic targets, efficient rendering and display of large batches of dynamic targets is achieved. The rendering and display of dynamic targets is a streaming task, which continuously loops through steps S2 to S4 until the task ends.

[0078] The aforementioned method for hierarchical display of large batches of dynamic targets based on aggregation and de-aggregation, in this application, employs H3 spatial grid coding to quickly locate the spatial distribution of dynamic targets and utilizes coding indexes to efficiently retrieve nearby target groups. This achieves accuracy close to distance-based clustering while avoiding extensive spatial geometric calculations. Furthermore, it uses hierarchical caching to periodically update the real-time status of dynamic targets, meeting user situational awareness requirements while reducing meaningless and frequent updates to target group states. During viewport window changes, aggregation and de-aggregation are performed based on existing target groups, saving computation time compared to aggregation and de-aggregation based on individual targets. Through these optimizations in aggregation calculation, the efficiency and accuracy of dynamic target aggregation are improved, achieving efficient rendering and display of large batches of dynamic targets.

[0079] In one embodiment, the update period of the buffer, the buffer boundaries, and the clustering level of the spatial network are initialized to obtain an initialized buffer, including:

[0080] Set the first-level update cycle and the second-level update cycle according to the pre-set real-time location display accuracy requirements of dynamic targets; set the classification boundaries of the first-level buffer and the second-level buffer according to the currently acquired geographic spatial range of the view window;

[0081] The collision radius is calculated based on the currently acquired view window map resolution and the size of the plotted symbols. The H3 spatial grid resolution table is then consulted, and the level with the largest average side length of the regular hexagon less than the collision radius is taken as the clustering level of the spatial grid.

[0082] In a specific embodiment, the first-level update cycle represents the data update interval in the first-level buffer, which is relatively short. The first-level buffer represents dynamic target data within the view window. The second-level update cycle represents the data update interval in the second-level buffer, which is relatively long. The second-level buffer represents dynamic target data outside the view window.

[0083] H3 is an open-source, multi-level geospatial discrete grid indexing system from Uber, widely used for geospatial data analysis. Using H3 spatial grid coding, one can quickly locate the belonging spatial grid and adjacent spatial grids. The relationship between the H3 spatial grid hierarchy and grid side length is shown in Table 1 below:

[0084] Table 1

[0085] 0 1,281,256.011 122 1 483,056.8391 842 2 182,512.9565 5,882 3 68,979.22179 41,162 4 26,071.75968 288,122 5 9,854.09099 2,016,842 6 3,724.532667 14,117,882 7 1,406.475763 98,825,162 8 531.41401 691,776,122 9 200.786148 4,842,432,842 10 75.863783 33,897,029,882 11 28.663897 237,279,209,162 12 10.830188 1,660,954,464,122 13 4.09201 11,626,681,248,842 14 1.5461 81,386,768,741,882 15 0.584169 569,707,381,193,162

[0086] H3 spatial grid encoding occupies 64 bits and can be represented by a 4-byte integer. The specific encoding rules are as follows:

[0087] Bit 0: Reserved; Bits 1-4: Index mode. 0 indicates invalid, 1 indicates a normal grid, 2 indicates a one-way edge, 3 indicates a two-way edge, and 4 indicates vertex mode; Bits 5-7: If the index mode is 0 or 1, it is not used; if it is 2 or 3, it indicates which edge of the hexagon this edge belongs to, with a value range of 1-6; if it is 4, it indicates that this vertex is the vertex number of its owner (0-5); Bits 8-11: Indicate the level, with a value range of 0-15; Bits 12-18: Base grid code, with a value range of 0-121; Bits 19-63: Every three bits represent the coordinates of one level.

[0088] By querying the H3 spatial grid resolution table, the clustering level of the spatial grid is set according to the maximum level where the average side length of the regular hexagon is less than the collision radius. Using the H3 spatial grid as the clustering basis, optimizing the square grid with the regular hexagonal grid can improve computational efficiency.

[0089] In one embodiment, the collision radius is calculated based on the currently acquired view window map resolution and the size of the plotted symbols, including:

[0090] The collision radius is calculated based on the current viewport map resolution and the size of the plotted symbols.

[0091] radius = resolution * length / 2

[0092] Where resolution represents the resolution of the currently acquired view window map, and length represents the size of the plotted symbols.

[0093] In one embodiment, the method of real-time access to dynamic target data, adding dynamic targets to different initialized buffers based on the dynamic target location information in the dynamic target data, further includes:

[0094] Based on the location information of the dynamic targets in the dynamic target data, the dynamic targets are added to different initialized buffers. If the location information of the dynamic target is within the geographic space of the view window, the corresponding dynamic target is added to the first-level buffer. If the location information of the dynamic target is outside the geographic space of the view window, the corresponding dynamic target is added to the second-level buffer.

[0095] In a specific embodiment, dynamic target data target(Rcv) is accessed in real time, and different buffers are added according to the location of the dynamic target. Specifically, the H3 spatial grid code code is calculated based on the latitude and longitude of the dynamic target, and the current location code target(Rcv).code1 = code is recorded. If the location of the dynamic target is within the Region (geographical range of the view window), the dynamic target is added to Cache1 (first-level buffer). If a dynamic target target(Cache) with the same ID exists in Cache1, that is, the dynamic target has been received in the current period, the target(Cache) information is updated, and target(Cache).code1 = code is recorded. If a dynamic target with the same ID does not exist in Cache1, but a dynamic target target(Set) with the same ID exists in TargetSet (dynamic target set), that is, the dynamic target has not been received in the current period but has been received in a previous period, the historical location code target(Rcv).code0 = target(Set).code1 is recorded, the target group to which it belongs is recorded target(Rcv).group = target(Set).group, and target(Rcv) is added to Cache1.

[0096] If there is no dynamic target with the same ID in Cache1 and there is no dynamic target with the same ID in TargetSet, that is, the dynamic target has not been received in the current period or in the historical period, record the historical position code target(Rcv).code0 as empty, record the target group to which it belongs target(Rcv).group as empty, and add target(Rcv) to Cache1;

[0097] If the location of the dynamic target is outside the Region (geospatial extent of the view window), the process of adding the dynamic target to Cache2 (secondary buffer) is similar to the process of adding the dynamic target to Cache1.

[0098] In one embodiment, if the location information of a dynamic target is within the geographic space of the view window, the corresponding dynamic target is added to the first-level buffer, and the method further includes:

[0099] If a dynamic target with the same ID exists in the first-level buffer, meaning that the dynamic target has been received in the current period, update the target (Cache) information and record the current position code target (Cache).code1 = code; where code1 represents the H3 spatial grid code of the latest position of the dynamic target, that is, the current position code code represents the H3 spatial grid code;

[0100] If no dynamic target with the same ID exists in the first-level buffer, but a dynamic target with the same ID, target(Set), exists in the dynamic target set (i.e., the target was not received in the current period but was received in a previous period), record the historical position code target(Rcv).code0 = target(Set).code1, and record the target group to which it belongs.

[0101] target(Rcv).group = target(Set).group, which adds target(Rcv) to the first-level buffer; where code0 represents the H3 spatial grid code of the position when the dynamic target is first added to the buffer, i.e., the historical position code, and group represents the target group identifier to which the dynamic target belongs;

[0102] If there is no dynamic target with the same ID in the first-level buffer, and there is no dynamic target with the same ID in the dynamic target set, that is, the dynamic target has not been received in the current period or in the historical period, the historical position code target(Rcv).code0 is recorded as empty, the target group to which it belongs is recorded as empty, and target(Rcv).group is added to the first-level buffer.

[0103] In one embodiment, each dynamic target is aggregated to obtain an initial target group set, including:

[0104] Step 1: Remove the current dynamic target from the buffer;

[0105] Step 2: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which the dynamic target belongs is empty, then aggregate the dynamic target;

[0106] Step 2.1: Add the dynamic target to the target group, extract the first 19 + (3*L) bits of the current position code of the dynamic target to form a prefix code, use the prefix code as an index to find the spatial grid to which the dynamic target belongs and the adjacent spatial grid, and search whether the target group exists in the grid; where L represents the spatial grid clustering level;

[0107] Step 2.1.1: If no target group exists in the spatial grid to which the dynamic target belongs or in the adjacent spatial grids, create a new target group, group, record the number of elements in the target group as group.num = 1, the target group location as group.location = target(Cache).location, and the target group location code as group.code = target(Cache).code1, add group to the target group set GroupSet; record the target group to which the dynamic target belongs as target(Cache).group = group;

[0108] Step 2.1.2: If there is only one target group (group) in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, add the dynamic target to the group and update the group information. The updated group information includes updating the target group location (group.location), updating the target group location code (group.code = code), updating the number of target group elements (group.num = group.num + 1), and recording the target group to which the dynamic target belongs (target(Cache).group = group).

[0109] Step 2.1.3: If multiple target groups exist in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, only temporarily deepen the grid clustering level in this process, that is, after setting the spatial grid clustering level L = L + 1, add the dynamic target to the target group, and extract the first 19 + (3 * L) bits of the current position code of the dynamic target to form a prefix code; use the prefix code as an index to find the spatial grid to which it belongs and the adjacent spatial grids, check whether there is a target group in the grid, and then execute step 2.1;

[0110] Step 2.2: Add the dynamic target to the dynamic target set;

[0111] Step 3: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which it belongs is not empty, remove the dynamic target from the original target group and aggregate the dynamic target. The aggregation process includes: obtaining the original target group group = target(Cache).group; removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the information of the original target group, including: updating the target group location group.location, updating the target group location code group.code = code, and updating the number of elements in the target group group.num = group.num-1; adding the dynamic target to the new target group.

[0112] The process of updating the target group location `group.location` is as follows: Convert the latitude and longitude coordinates of the target group location `group.location` to Cartesian coordinates x(group), y(group), z(group); convert the latitude and longitude coordinates of the dynamic target location `target(Cache).location` to Cartesian coordinates x(target), y(target), z(target); calculate the new Cartesian coordinates.

[0113] x(new)=(x(group)*group.num-x(target)) / (group.num-1);

[0114] y(new)=(y(group)*group.num-y(target)) / (group.num-1);

[0115] z(new)=(z(group)*group.num-z(target)) / (group.num-1);

[0116] Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form new location information location(new), and update the target group location group.location = location(new).

[0117] In one embodiment, updating the target group location group.location includes:

[0118] Convert the latitude and longitude coordinates of the target group location `group.location` to Cartesian coordinates `x(group), y(group), z(group)`; convert the latitude and longitude coordinates of the dynamic target location `target(Cache).location` to Cartesian coordinates `x(target), y(target), z(target)`; calculate the new Cartesian coordinates:

[0119] x(new)=(x(group)*group.num+x(target)) / (group.num+1);

[0120] y(new)=(y(group)*group.num+y(target)) / (group.num+1);

[0121] z(new)=(z(group)*group.num+z(target)) / (group.num+1);

[0122] Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form new location information location(new), and update the target group location group.location = location(new).

[0123] In one embodiment, when the stable duration of the viewport window exceeds the first-level update cycle, the update buffer hierarchy and spatial grid clustering level are used to perform aggregation and de-aggregation based on the existing initial target group set to obtain the target group set, including:

[0124] Step 4.1: When the stable duration of the viewport window exceeds the first-level update cycle, update the buffer hierarchy and spatial grid clustering level. Based on the existing initial target group set, perform aggregation and de-clustering. First, update the geographic spatial range of the viewport window. The update method for the geographic spatial range of the viewport window is as follows: after the viewport window stabilizes, obtain the maximum and minimum latitude and longitude range of the map corresponding to this viewport window. Traverse all dynamic targets in the first-level buffer. If a dynamic target is outside the updated geographic spatial range of the viewport window, move the dynamic target to the second-level buffer to obtain the updated second-level buffer. Traverse all dynamic targets in the second-level buffer. If a dynamic target is within the updated geographic spatial range of the viewport window, move the dynamic target to the first-level buffer to obtain the updated first-level buffer.

[0125] Step 4.2: Reinitialize the spatial grid clustering layer. If the current spatial grid clustering level is larger than the previous spatial grid clustering level, then disaggregate the target groups. Iterate through all target groups in the initial target group set. For target groups whose location is within the updated view window's geographic space and whose number of dynamic targets is greater than 1, iterate through all dynamic targets in the target group and update the target group to which the dynamic target belongs. The update process includes: removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the original target group information, including: updating the target group location group.location, updating the target group location code group.code = code, and updating the number of elements in the target group group.num = group.num - 1; or adding the dynamic target to a new target group, as detailed in Step 2.1.

[0126] Step 4.3: If the current spatial grid clustering level is smaller than the spatial grid clustering level at the previous time step, then perform target group aggregation, including:

[0127] Step 4.3.1: Traverse all target groups in the initial target group set, remove target groups whose locations are within the geospatial range of the updated view window from the target group set, and add them to the temporary target group set;

[0128] Step 4.3.2: Traverse all target groups in the temporary target group set, and aggregate each target group, including:

[0129] Step 4.3.2.1: Extract the first 19 + (3*L) bits of the current position code of the target group group(old) to form a prefix code; using the prefix code as an index, find the spatial grid to which the target group belongs and the adjacent spatial grid, and check whether the target group exists in the grid. If the target group does not exist in the belonging spatial grid and the adjacent spatial grid, create a new target group group, record group.num = group(old).num, group.location = group(old).location, group.code = group(old).code, and add group to GroupSet; iterate through all dynamic targets in group(old), and further... Each dynamic target belongs to a target group named "group". If there is only one target group "group" in the target space grid and adjacent spatial grids, add "group(old)" to "group" and update the group information. The updated group information includes: updating the target group location "group.location", updating the target group location code "group.code = code", updating the number of target group elements "group.num = num", and updating the target group to which each dynamic target belongs to "group". If there are multiple target groups in the target space grid and adjacent spatial grids, only temporarily deepen the grid clustering level in this step, that is, set the spatial grid clustering level L = L + 1, and jump to step 4.3.2.1.

[0130] The update process for the target group location `group.location` includes: converting the latitude and longitude coordinates of `group.location` to Cartesian coordinates x(group), y(group), z(group); converting the latitude and longitude coordinates of `group(old).location` to Cartesian coordinates x(old), y(old), z(old); and calculating the new Cartesian coordinates.

[0131] num=group.num+group(old).num;

[0132] x(new)=(x(group)*group.num+x(old)*group(old).num) / num;

[0133] y(new)=(y(group)*group.num+y(old)*group(old).num) / num;

[0134] z(new)=(z(group)*group.num+z(old)*group(old).num) / num;

[0135] Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form the location information location(new), and record group.location = location(new).

[0136] In one embodiment, all target groups in the target group set are traversed, and the symbol rendering of each target group is refreshed to obtain a dynamic target layered display result, including:

[0137] Iterate through all target groups in the target group set. If the number of dynamic targets in a target group is 0, delete the target group drawing symbol and remove the target group from the target group set. If the target group is a newly added target group, create a new drawing symbol on the map, with the symbol position being the target group position, and mark the number of target group elements in the upper right corner of the symbol. If the target group is an existing target group, refresh the symbol position to the target group position, and refresh the number in the upper right corner of the symbol to show the number of target group elements.

[0138] It should be understood that, although Figure 1 The steps in the flowchart are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order in which these steps are executed, and they can be performed in other orders. Figure 1 At least some of the steps in the process may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0139] In one embodiment, such as Figure 2 As shown, a large-scale dynamic target hierarchical display device based on aggregation and deaggregation is provided, including: an initialization module 202, an aggregation module 204, a target group set aggregation and deaggregation module 206, and a dynamic target hierarchical display module 208, wherein:

[0140] Initialization module 202 is used to obtain the buffer for the dynamic target hierarchical display; it initializes the update period of the buffer, the buffer boundary and the clustering level of the spatial network to obtain the initialized buffer;

[0141] The aggregation module 204 is used to access dynamic target data in real time. Based on the dynamic target location information in the dynamic target data, the dynamic targets are added to different initialized buffers. After each update cycle, all dynamic targets in the initialized buffers are traversed, and each dynamic target is aggregated to obtain an initial target group set.

[0142] The target group set aggregation and de-aggregation module 206 is used to update the buffer hierarchical method and spatial grid clustering level when the stable duration of the view window exceeds the first-level update cycle, and to perform aggregation and de-aggregation based on the existing initial target group set to obtain the target group set.

[0143] The dynamic target layered display module 208 is used to traverse all target groups in the target group set, refresh the symbol drawing of each target group, and obtain the dynamic target layered display result.

[0144] Specific limitations regarding the mass dynamic target hierarchical display device based on aggregation and deaggregation can be found in the limitations of the mass dynamic target hierarchical display method based on aggregation and deaggregation mentioned above, and will not be repeated here. Each module in the aforementioned mass dynamic target hierarchical display device based on aggregation and deaggregation can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device in hardware form, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0145] In one embodiment, a computer device is provided, which may be a terminal, and its internal structure diagram may be as follows: Figure 3 As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The network interface is used to communicate with external terminals via a network connection. When executed by the processor, the computer program implements a method for large-scale dynamic target hierarchical display based on aggregation and deaggregation. The display screen can be a liquid crystal display (LCD) or an e-ink display. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad mounted on the computer device casing, or an external keyboard, touchpad, or mouse.

[0146] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0147] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0148] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by the appended claims.

Claims

1. A method for large-scale dynamic target hierarchical display based on aggregation and deaggregation, characterized in that, The method includes: Step A: Obtain the buffer for dynamic target hierarchical display; initialize the update period, buffer boundaries, and spatial network clustering level of the buffer to obtain the initialized buffer; Step B: Real-time access to dynamic target data; based on the dynamic target location information in the dynamic target data, add the dynamic targets to different initialized buffers. After each update cycle, iterate through all dynamic targets in the initialized buffers, aggregate each dynamic target, and obtain an initial target group set, including: Step 1: Remove the current dynamic target from the buffer; Step 2: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which the dynamic target belongs is empty, then aggregate the dynamic target; Step 2.1: Add the dynamic target to the target group, extract the first 19 + (3*L) bits of the current position code of the dynamic target to form a prefix code, use the prefix code as an index to find the spatial grid to which the dynamic target belongs and the adjacent spatial grid, and search whether the target group exists in the grid; where L represents the spatial grid clustering level; Step 2.1.1: If no target group exists in the spatial grid to which the dynamic target belongs or in the adjacent spatial grids, create a new target group, group, record the number of elements in the target group as group.num=1, the target group location as group.location=target(Cache).location, and the target group location code as group.code=target(Cache).code1, add group to the target group set GroupSet; record the target group to which the dynamic target belongs as target(Cache).group=group; Step 2.1.2: If there is only one target group (group) in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, add the dynamic target to the group and update the group information. The updated group information includes updating the target group location (group.location), updating the target group location code (group.code=code), updating the number of elements in the target group (group.num=group.num+1), and recording the target group to which the dynamic target belongs (target(Cache).group=group). Step 2.1.3: If multiple target groups exist in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, only temporarily deepen the grid clustering level in this process, that is, after setting the spatial grid clustering level L=L+1, add the dynamic target to the target group, and extract the first 19+(3*L) bits of the current position code of the dynamic target to form a prefix code; use the prefix code as an index to find the spatial grid to which it belongs and the adjacent spatial grids, check whether there is a target group in the grid, and then execute step 2.1; Step 2.2: Add the dynamic target to the dynamic target set; Step 3: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which it belongs is not empty, remove the dynamic target from the original target group and aggregate the dynamic target. The aggregation process includes: obtaining the original target group group=target(Cache).group; removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the information of the original target group, including: updating the target group location group.location, updating the target group location code group.code=code, and updating the number of elements in the target group group.num=group.num-1; adding the dynamic target to the new target group. Step C: When the stable duration of the viewport window exceeds the first-level update cycle, update the buffer hierarchy and spatial grid clustering level, and perform aggregation and de-aggregation based on the existing initial target group set to obtain the target group set, including: Step 4.1: When the stable duration of the viewport window exceeds the first-level update cycle, update the buffer hierarchy and spatial grid clustering level. Based on the existing initial target group set, perform aggregation and de-clustering. First, update the geospatial extent of the viewport window. Traverse all dynamic targets in the first-level buffer. If a dynamic target is outside the updated geospatial extent of the viewport window, move the dynamic target to the second-level buffer to obtain the updated second-level buffer. Traverse all dynamic targets in the second-level buffer. If a dynamic target is within the updated geospatial extent of the viewport window, move the dynamic target to the first-level buffer to obtain the updated first-level buffer. Step 4.2: Reinitialize the spatial grid clustering layer. If the current spatial grid clustering level is larger than the previous spatial grid clustering level, then disaggregate the target groups. Iterate through all target groups in the initial target group set. For target groups whose location is within the updated viewport window's geographic space and whose number of dynamic targets is greater than 1, iterate through all dynamic targets in the target group and update the target group to which the dynamic target belongs. The update process includes: removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the original target group information, including: updating the target group location group.location, updating the target group location code group.code=code, and updating the number of elements in the target group group.num=group.num-1; or adding the dynamic target to a new target group, as described in Step 2.

1. Step 4.3: If the current spatial grid clustering level is smaller than the spatial grid clustering level at the previous time step, then perform target group aggregation, including: Step 4.3.1: Traverse all target groups in the initial target group set, remove target groups whose locations are within the geospatial range of the updated view window from the target group set, and add them to the temporary target group set; Step 4.3.2: Traverse all target groups in the temporary target group set, and aggregate each target group, including: Step 4.3.2.1: Extract the first 19 + (3*L) bits of the current position code of the target group group(old) to form a prefix code; using the prefix code as an index, find the spatial grid to which the target group belongs and the adjacent spatial grid, and check whether the target group exists in the grid. If the target group does not exist in the belonging spatial grid and the adjacent spatial grid, create a new target group group, record group.num = group(old).num, group.location = group(old).location, group.code = group(old).code, and add group to GroupSet; iterate through all dynamic targets in group(old), and further... Each dynamic target belongs to a target group named "group". If there is only one target group "group" in the target space grid and adjacent spatial grids, add "group(old)" to "group" and update the group information, including updating the target group location "group.location", updating the target group location code "group.code=code", updating the number of target group elements "group.num=num", and updating the target group to which each dynamic target belongs to "group". If there are multiple target groups in the target space grid and adjacent spatial grids, only temporarily deepen the grid clustering level in this step, that is, set the spatial grid clustering level L=L+1, and jump to step 4.3.2.

1. The update process for the target group location `group.location` includes: converting the latitude and longitude coordinates of `group.location` to Cartesian coordinates x(group), y(group), z(group); converting the latitude and longitude coordinates of `group(old).location` to Cartesian coordinates x(old), y(old), z(old); and calculating the new Cartesian coordinates. num = group.num + group(old).num; x(new)=(x(group)*group.num+x(old)*group(old).num) / num; y(new)=(y(group)*group.num+y(old)*group(old).num) / num; z(new)=(z(group)*group.num+z(old)*group(old).num) / num; Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form location information location(new), and record group.location = location(new); Step D: Traverse all target groups in the target group set, refresh the symbol drawing of each target group, and obtain the dynamic target layer display result.

2. The method according to claim 1, characterized in that, The update cycle, buffer boundaries, and spatial network clustering levels of the buffer are initialized to obtain the initialized buffer, including: Set the first-level update cycle and the second-level update cycle according to the pre-set real-time location display accuracy requirements of dynamic targets; set the classification boundaries of the first-level buffer and the second-level buffer according to the currently acquired geographic spatial range of the view window; The collision radius is calculated based on the currently acquired view window map resolution and the size of the plotted symbols. The H3 spatial grid resolution table is then queried, and the level with the largest average side length of the regular hexagon less than the collision radius is taken as the clustering level of the spatial grid.

3. The method according to claim 2, characterized in that, The collision radius is calculated based on the currently acquired viewport map resolution and the size of the plotted symbols, including: The collision radius is calculated based on the current viewport map resolution and the size of the plotted symbols. radius = resolution * length / 2 Where resolution represents the resolution of the currently acquired view window map, and length represents the size of the plotted symbols.

4. The method according to any one of claims 1 to 3, characterized in that, Real-time access to dynamic target data, adding dynamic targets to different initialized buffers based on the dynamic target location information in the dynamic target data, and further including: Based on the dynamic target location information in the dynamic target data, the dynamic targets are added to different initialized buffers. If the dynamic target location information is within the geographic space of the view window, the corresponding dynamic target is added to the first-level buffer. If the dynamic target location information is outside the geographic space of the view window, the corresponding dynamic target is added to the second-level buffer.

5. The method according to claim 4, characterized in that, If the location information of a dynamic target is within the geographic space of the view window, the corresponding dynamic target is added to the first-level buffer, which also includes: If a dynamic target with the same ID exists in the first-level buffer, meaning that the dynamic target has been received in the current period, update the target (Cache) information and record the current position code target (Cache).code1 = code; where code1 represents the H3 spatial grid code of the latest position of the dynamic target, that is, the current position code code represents the H3 spatial grid code; If no dynamic target with the same ID exists in the first-level buffer, but a dynamic target with the same ID, target(Set), exists in the dynamic target set (i.e., the target was not received in the current period but was received in a previous period), record the historical position code target(Rcv).code0 = target(Set).code1, and record the target group to which it belongs. target(Rcv).group=target(Set).group, adds target(Rcv) to the first-level buffer; where code0 represents the H3 spatial grid code of the position when the dynamic target is first added to the buffer, i.e., the historical position code, and group represents the target group identifier to which the dynamic target belongs; If there is no dynamic target with the same ID in the first-level buffer, and there is no dynamic target with the same ID in the dynamic target set, that is, the dynamic target has not been received in the current period or in the historical period, the historical position code target(Rcv).code0 is recorded as empty, the target group to which it belongs is recorded as empty, and target(Rcv).group is added to the first-level buffer.

6. The method according to claim 1, characterized in that, Update the target group location group.location, including: Convert the latitude and longitude coordinates of the target group location `group.location` to Cartesian coordinates `x(group), y(group), z(group)`; convert the latitude and longitude coordinates of the dynamic target location `target(Cache).location` to Cartesian coordinates `x(target), y(target), z(target)`; calculate the new Cartesian coordinates: x(new)=(x(group)*group.num+x(target)) / (group.num+1); y(new)=(y(group)*group.num+y(target)) / (group.num+1); z(new)=(z(group)*group.num+z(target)) / (group.num+1); Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form new location information location(new), and update the target group location group.location=location(new).

7. The method according to claim 1, characterized in that, Traverse all target groups in the target group set, refresh the symbol rendering for each target group, and obtain the dynamic target layered display result, including: Iterate through all target groups in the target group set. If the number of dynamic targets in a target group is 0, delete the target group drawing symbol and remove the target group from the target group set. If the target group is a newly added target group, create a new drawing symbol on the map, with the symbol position being the target group position, and mark the number of target group elements in the upper right corner of the symbol. If the target group is an existing target group, refresh the symbol position to the target group position, and refresh the number in the upper right corner of the symbol to show the number of target group elements.

8. A large-scale dynamic target layered display device based on aggregation and deaggregation, characterized in that, The device includes: An initialization module is used to obtain a buffer for the hierarchical display of dynamic targets; the update period, buffer boundaries, and clustering levels of the spatial network of the buffer are initialized to obtain an initialized buffer; The aggregation module is used to receive dynamic target data in real time. Based on the dynamic target location information in the dynamic target data, it adds the dynamic targets to different initialized buffers. After each update cycle, it iterates through all dynamic targets in the initialized buffers, aggregates each dynamic target, and obtains an initial target group set, including: Step 1: Remove the current dynamic target from the buffer; Step 2: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which the dynamic target belongs is empty, then aggregate the dynamic target; Step 2.1: Add the dynamic target to the target group, extract the first 19 + (3*L) bits of the current position code of the dynamic target to form a prefix code, use the prefix code as an index to find the spatial grid to which the dynamic target belongs and the adjacent spatial grid, and search whether the target group exists in the grid; where L represents the spatial grid clustering level; Step 2.1.1: If no target group exists in the spatial grid to which the dynamic target belongs or in the adjacent spatial grids, create a new target group, group, record the number of elements in the target group as group.num=1, the target group location as group.location=target(Cache).location, and the target group location code as group.code=target(Cache).code1, add group to the target group set GroupSet; record the target group to which the dynamic target belongs as target(Cache).group=group; Step 2.1.2: If there is only one target group (group) in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, add the dynamic target to the group and update the group information. The updated group information includes updating the target group location (group.location), updating the target group location code (group.code=code), updating the number of elements in the target group (group.num=group.num+1), and recording the target group to which the dynamic target belongs (target(Cache).group=group). Step 2.1.3: If multiple target groups exist in the spatial grid to which the dynamic target belongs and in the adjacent spatial grids, only temporarily deepen the grid clustering level in this process, that is, after setting the spatial grid clustering level L=L+1, add the dynamic target to the target group, and extract the first 19+(3*L) bits of the current position code of the dynamic target to form a prefix code; use the prefix code as an index to find the spatial grid to which it belongs and the adjacent spatial grids, check whether there is a target group in the grid, and then execute step 2.1; Step 2.2: Add the dynamic target to the dynamic target set; Step 3: If the historical location code of the current dynamic target is not equal to the current location code and the target group to which it belongs is not empty, remove the dynamic target from the original target group and aggregate the dynamic target. The aggregation process includes: obtaining the original target group group=target(Cache).group; removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the information of the original target group, including: updating the target group location group.location, updating the target group location code group.code=code, and updating the number of elements in the target group group.num=group.num-1; adding the dynamic target to the new target group. The target group set aggregation and de-aggregation module is used to update the buffer hierarchy and spatial grid clustering level when the stable duration of the viewport window exceeds the first-level update cycle. It performs aggregation and de-aggregation based on the existing initial target group set to obtain the target group set, which includes: Step 4.1: When the stable duration of the viewport window exceeds the first-level update cycle, update the buffer hierarchy and spatial grid clustering level. Based on the existing initial target group set, perform aggregation and de-clustering. First, update the geospatial extent of the viewport window. Traverse all dynamic targets in the first-level buffer. If a dynamic target is outside the updated geospatial extent of the viewport window, move the dynamic target to the second-level buffer to obtain the updated second-level buffer. Traverse all dynamic targets in the second-level buffer. If a dynamic target is within the updated geospatial extent of the viewport window, move the dynamic target to the first-level buffer to obtain the updated first-level buffer. Step 4.2: Reinitialize the spatial grid clustering layer. If the current spatial grid clustering level is larger than the previous spatial grid clustering level, then disaggregate the target groups. Iterate through all target groups in the initial target group set. For target groups whose location is within the updated viewport window's geographic space and whose number of dynamic targets is greater than 1, iterate through all dynamic targets in the target group and update the target group to which the dynamic target belongs. The update process includes: removing the dynamic target from the original target group; if the number of elements in the original target group is 1, setting the number of elements in the original target group to 0; if the number of elements in the original target group is greater than 1, updating the original target group information, including: updating the target group location group.location, updating the target group location code group.code=code, and updating the number of elements in the target group group.num=group.num-1; or adding the dynamic target to a new target group, as described in Step 2.

1. Step 4.3: If the current spatial grid clustering level is smaller than the spatial grid clustering level at the previous time step, then perform target group aggregation, including: Step 4.3.1: Traverse all target groups in the initial target group set, remove target groups whose locations are within the geospatial range of the updated view window from the target group set, and add them to the temporary target group set; Step 4.3.2: Traverse all target groups in the temporary target group set, and aggregate each target group, including: Step 4.3.2.1: Extract the first 19 + (3*L) bits of the current position code of the target group group(old) to form a prefix code; using the prefix code as an index, find the spatial grid to which the target group belongs and the adjacent spatial grid, and check whether the target group exists in the grid. If the target group does not exist in the belonging spatial grid and the adjacent spatial grid, create a new target group group, record group.num = group(old).num, group.location = group(old).location, group.code = group(old).code, and add group to GroupSet; iterate through all dynamic targets in group(old), and further... Each dynamic target belongs to a target group named "group". If there is only one target group "group" in the target space grid and adjacent spatial grids, add "group(old)" to "group" and update the group information, including updating the target group location "group.location", updating the target group location code "group.code=code", updating the number of target group elements "group.num=num", and updating the target group to which each dynamic target belongs to "group". If there are multiple target groups in the target space grid and adjacent spatial grids, only temporarily deepen the grid clustering level in this step, that is, set the spatial grid clustering level L=L+1, and jump to step 4.3.2.

1. The update process for the target group location `group.location` includes: converting the latitude and longitude coordinates of `group.location` to Cartesian coordinates x(group), y(group), z(group); converting the latitude and longitude coordinates of `group(old).location` to Cartesian coordinates x(old), y(old), z(old); and calculating the new Cartesian coordinates. num = group.num + group(old).num; x(new)=(x(group)*group.num+x(old)*group(old).num) / num; y(new)=(y(group)*group.num+y(old)*group(old).num) / num; z(new)=(z(group)*group.num+z(old)*group(old).num) / num; Convert the new Cartesian coordinates x(new), y(new), z(new) into latitude and longitude coordinates to form location information location(new), and record group.location = location(new); The dynamic target layered display module is used to traverse all target groups in the target group set, refresh the symbol drawing of each target group, and obtain the dynamic target layered display result.

Images