Tianyan panoramic space-time data twin and dynamic display platform

Abstract

The present application belongs to the field of computer data processing and digital twin technology, and specifically relates to a sky-eye panoramic space-time data twin and dynamic display platform. The platform encapsulates panoramic space-time data as space-time events containing event occurrence time, spatial scope, associated twin entities, state change quantity and causal preposition identifier, writes the space-time causal ledger according to the twin entities, and constructs a causal dependency graph according to entity association, spatial scope overlap and state conversion constraints; after a late event passes the causal admission judgment, the minimum dependency subgraph is determined, the state increment is reversed in reverse topological order, the late event and the subsequent event are replayed in causal order, and the display state of the corresponding entity, spatial range and time interval is replaced according to the replay result. Thus, the consistency of the twin state, historical track and dynamic picture can be maintained under the condition of asynchronous and out-of-order access of multi-source data, and global rollback, full recalculation and whole cache invalidation are reduced.

Description

Technical Field

[0001] This invention belongs to the field of computer data processing and digital twin technology, specifically the Sky Eye panoramic spatiotemporal data twin and dynamic display platform. Background Technology

[0002] Digital twin platforms typically build entity models, attribute models, and spatial indexes for continuously arriving spatiotemporal data, mapping collected records to corresponding twin entities according to data source identifiers, object identifiers, and timestamps. The conventional approach involves format conversion, coordinate unification, and time base conversion at the access end, followed by data consumption in the order of receipt via message queues or streaming programs. When multiple update records appear for the same attribute of the same entity, the platform generally generates the current state using timestamp sorting, latest value overwriting, or fixed priority merging, and periodically creates state snapshots. The dynamic display end reads entity location, trajectory, and attribute changes from the current state database, converts the changed data into local layers, spatial tiles, or time segments, and writes them to the display cache. This type of solution has relatively straightforward implementation logic and is suitable for scenarios with a small number of data sources, stable network latency, and where the order of event arrival is largely consistent with the actual occurrence order. However, its state updates are primarily based on temporal relationships, lacking joint constraints on entity inheritance, state references, spatial scope, and state transition conditions between events.

[0003] To handle delays and out-of-order data from multiple sources, existing technologies typically set waiting windows in the streaming processing chain, reordering data within the window, or using a unified clock service to correct time discrepancies between different data sources. Late data exceeding the waiting window is discarded, saved as supplementary records, or overwritten according to a preset data source level. Some digital twin platforms also save historical states through periodic snapshots and operation logs. When an anomaly is detected, subsequent data is re-executed after restoring from the most recent snapshot. If the displayed screen is inconsistent with the state database, the relevant cache is cleared and the data for the corresponding time period or spatial region is reloaded. While these methods can correct some short-term out-of-order issues, waiting windows struggle to adapt to continuously changing transmission latency, fixed data source levels cannot reflect the true dependency between specific events and preceding and following states, and snapshot restoration cannot directly determine the actual set of entities and state range affected by the late event. When the platform chooses to expand the rollback interval to avoid omissions, a large amount of unaffected data is recalculated; when it chooses to shrink the rollback interval, subsequent states derived from erroneous preceding states may be retained.

[0004] When panoramic spatiotemporal data is asynchronously accessed from multiple data sources, and the order of events occurs is inconsistent with the order in which the platform receives the data, how can we, based on verifiable causal dependencies between events, reposition late or conflicting events into the correct twin state evolution chain, and only perform undo and replay on the affected state branches, spatial ranges, and time intervals? This ensures consistency between the corrected entity states, historical trajectories, and dynamic display results, while avoiding large-scale redundant processing caused by global rollback, full recalculation, or entire cache invalidation. The essence of this problem is that conventional timestamp sorting can only determine the superficial order of records; it cannot determine whether subsequent states actually reference attribute versions formed by preceding events, nor can it define the minimum impact boundary of late events. Therefore, it cannot simultaneously satisfy the completeness of state correction and the limitation of local processing. Its processing boundary should be determined by the state reference path of the events, and cannot be replaced by fixed waiting windows, preset rollback durations, or data source level rules. Summary of the Invention

[0005] The purpose of this invention is to provide a panoramic spatiotemporal data twin and dynamic display platform for the Sky Eye, which can solve the problems mentioned in the background art.

[0006] To achieve the above objectives, the technical solution adopted by the present invention is as follows: The Sky Eye Panoramic Spatiotemporal Data Twin and Dynamic Display Platform includes a data event processing module, a spatiotemporal causal ledger, a causal dependency graph generation module, a locally reversible playback module, and a dynamic display synchronization module. The data event processing module encapsulates the accessed panoramic spatiotemporal data into spatiotemporal events with event occurrence time, platform reception time, spatial scope, associated twin entity, state change quantity, and causal pre-identification. The spatiotemporal causal ledger appends the spatiotemporal events according to the twin entity; The causal dependency graph generation module constructs directed dependency relationships between events based on entity association, overlapping spatial domains, and state transition constraints. After the late event passes the causal admission judgment, the local reversible replay module determines the minimum dependent subgraph affected by the late event, cancels the state increment corresponding to the minimum dependent subgraph, and replays it in causal order. The dynamic display synchronization module replaces the display status of the corresponding twin entity and time interval based on the replay results.

[0007] Preferably, the data event processing module includes a time semantic normalization process and an event version orchestration process; The time semantic normalization process retains the data source time, event occurrence time, and platform reception time respectively, and determines the time offset based on the continuous state records of the same twin entity. The time offset is written into the event time correction field without rewriting the original time field. The event version orchestration process uses twin entity identifiers, state attribute identifiers, and spatial scope identifiers to form event version keys. For new spatiotemporal events with the same event version key, a preceding version reference, a parallel candidate version reference, or a supplementary version reference is established, so that the spatiotemporal causal ledger can simultaneously save the original event order, the corrected event order, and the version evolution relationship.

[0008] Preferably, the causal dependency graph generation module extracts the twin entity inheritance relationship, spatial scope overlap relationship, state attribute transfer relationship and state transition reachability relationship for any preceding and subsequent events to be connected, and establishes causal edges only when the subsequent event references the entity state formed by the preceding event and satisfies the corresponding state transition constraint. The causal edge records the referenced state attributes, scope of action, and allowed event time intervals; For late events whose event time falls within the allowed event time interval but whose reception time is later than the subsequent event, the causal admission determination is performed according to the causal edge, and late events that do not satisfy the state transition reachability relationship are written into the isolated branch instead of being merged into the current state chain.

[0009] Preferably, the locally reversible replay module starts with the late event determined by the causal admission criteria, searches along the outgoing edges of the causal dependency graph for subsequent events that reference the same state attribute, are in the intersecting space scope, and whose event time is no earlier than the late event, and terminates the search when it encounters a boundary event that has been determined by independent evidence and no longer references the aforementioned state attribute, so as to form a minimum dependency subgraph. The locally reversible replay module calls the state inverse operation records corresponding to each event in the reverse topological order of the minimum dependency subgraph to restore the baseline state, and then resubmits the late event and the subsequent event in the minimum dependency subgraph to the twin state chain in the topological order.

[0010] Preferably, the time semantic normalization process involves maintaining a time correction description consisting of stable time anchors and drift intervals for each data source. The stable time anchors are jointly determined by consistent state switching records of the same twin entity in different data sources, and the drift intervals are generated by the time offset changes between adjacent stable time anchors. When a new spatiotemporal event lacks a reliable event occurrence time, a candidate event time range is generated according to the drift interval where its data source time is located, and the candidate event time range is narrowed using previous version references and subsequent version references; When the time range of the candidate events after shrinking still covers multiple insertable locations, the corresponding spatiotemporal events are established as multiple temporary time branches that share the same original event identifier.

[0011] Preferably, the isolated branches are organized according to conflict event groups, each conflict event group consisting of candidate events that point to the same twin entity, have the same state attribute, and have overlapping event time intervals; The causal dependency graph generation module calculates the state transition reachable path between each candidate event and its predecessor event, the state reference closed path between each candidate event and its successor event, and the spatially consistent path between each candidate event and its associated twin entity event. The candidate event that simultaneously forms forward reachability, backward closure and spatial consistency is then connected to the current state chain. Candidate events that are not connected to the current state chain retain their original causal edges and version references, and the connection determination is re-executed when a new state reference closure path is formed by subsequent events.

[0012] Preferably, the state inverse operation record is associated with both the event state increment and includes the attribute version identifier before the increment, the reference of the replaced value, the spatial slice reference, and the reference of the associated entity edge. After forming the minimum dependency subgraph, the local reversible replay module groups successor events with a common preceding state version into parallel replay groups, establishes temporary state branches for different parallel replay groups, and performs branch merging based on attribute version continuity, spatial slice mutual exclusion, and associated entity edge consistency after each temporary state branch has completed replay. For temporary state branches with overlapping writes that cannot meet the attribute version continuity requirement, retain them until the corresponding conflict event group completes the access determination before continuing to merge.

[0013] Preferably, the dynamic display synchronization module maintains the spatial tile cache and time segment cache corresponding to the twin state version of the display screen, and maps the minimum dependency subgraph to a display patch list consisting of twin entity identifier, attribute version range, spatial tile set and time segment set; The dynamic display synchronization module only invalidates cached items that overlap with the display patch list, converts the replayed state increment into local display patches arranged in chronological order, and inserts continuous state segments from the previous valid state to the next valid state between adjacent patches of the same twin entity. Cache items that do not overlap with the patch list shown will retain their original version and participate in subsequent screen composition.

[0014] Preferably, the locally reversible replay module sets replay checkpoints in each temporary state branch, which are jointly identified by the attribute version set, the spatial slice set, and the committed event set, and compares the state increment summary and causal prereference of the corresponding event when the replay event reaches an existing replay checkpoint. When the two are consistent, the existing state chain after the replay checkpoint is reused and the replay of the corresponding temporary state branch is terminated. When the two are inconsistent, a new temporary state branch is generated from the earliest checkpoint corresponding to the difference attribute version, and the existing state chain that was replaced is registered as a recyclable version until the new temporary state branch releases the recyclable version after passing the attribute version continuity and associated entity edge consistency checks.

[0015] Preferably, the dynamic display synchronization module adds a display version identifier corresponding to the replay checkpoint to each local display patch, and establishes a patch submission chain according to the causal order of the same twin entity; When a new temporary state branch is generated during the replay process, the corresponding local display patch is first written to the invisible display branch. After the temporary state branch passes the checks of attribute version continuity, spatial slice mutual exclusion and associated entity edge consistency, the invisible display branch is atomically switched with the current patch commit chain. When a temporary state branch is registered as the recyclable version, delete the local display patch associated with the recyclable version that has not yet completed an atomic switch, and retain the most recent valid display version referenced by the current screen.

[0016] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. By encapsulating panoramic spatiotemporal data into spatiotemporal events containing event occurrence time, platform reception time, spatial scope, associated twin entities, state change variables, and causal pre-identifiers, and writing these into a spatiotemporal causal ledger by twin entities, continuous records of original events, version evolution, and state references can be preserved. The causal dependency graph establishes directed dependencies based on entity associations, overlapping spatial scopes, and state transition constraints, ensuring that whether a late event can enter the current state chain and whether its subsequent states are affected are determined by specific dependency edges. Local reversible replay starts with late events that pass causal admission criteria, forms a minimum dependency subgraph along the dependencies, restores the baseline state in reverse topological order, and resubmits events in topological order, thus limiting the scope of undoing and replay to entities, attributes, spatial slices, and time segments of the actual referenced preceding state. The dynamic display client replaces local caches and display states according to the corresponding patch list, ensuring that state library corrections and screen updates use the same dependency scope, reducing redundant calculations of unaffected states and redundant generation of unaffected screens.

[0017] 2. Time semantic regularization preserves the data source time, event occurrence time, and platform reception time. It utilizes stable time anchors, drift intervals, and version references to narrow the time range of candidate events, avoiding traceability breaks caused by directly rewriting the original time. For events with multiple possible insertion points, different time interpretations are preserved through temporary time branches. Conflicting events are grouped according to the same entity, same attribute, and overlapping time intervals. Access branches are determined by combining the reachable path of forward state transitions, the closed path of backward state references, and the consistent path of associated entity space, ensuring that candidate events not accessed retain causal edges and version references. During replay, state inverse operation records, parallel replay groups, temporary state branches, and replay checkpoints are used. This allows reuse of existing state chains consistent with state increment summaries and causal preceding references, and performs version continuity checks on overlapping write branches. Display patches correspond to replay checkpoints and are atomically switched through invisible display branches, preventing intermediate states that have not yet completed verification from entering the current screen. Attached Figure Description

[0018] Figure 1 Main flowchart for the panoramic spatiotemporal data twin and dynamic display of FAST (Five-hundred-meter Aperture Spherical Telescope); Figure 2 A flowchart for time semantic regularization and event version orchestration; Figure 3 A flowchart illustrating the conflict handling and patch switching process; Figure 4 A comparison chart of time offset drift trends for multiple types of access data sources; Figure 5 Statistical curve of event time correction interval window; Figure 6 A statistical chart of the indicators for accepting and judging conflict events. Detailed Implementation

[0019] In one embodiment, a panoramic spatiotemporal data twin and dynamic display platform is provided, including a data event processing module, a spatiotemporal causal ledger, a causal dependency graph generation module, a locally reversible playback module, and a dynamic display synchronization module. The data event processing module encapsulates the accessed panoramic spatiotemporal data into spatiotemporal events with event occurrence time, platform reception time, spatial scope, associated twin entities, state change variables, and causal pre-identification. The spatiotemporal causal ledger appends spatiotemporal events according to twin entities. The causal dependency graph generation module constructs directed dependencies between events based on entity association, spatial scope overlap, and state transition constraints. After a late event passes the causal admission judgment, the locally reversible playback module determines the minimum dependency subgraph affected by the late event, cancels the state increment corresponding to the minimum dependency subgraph, and replays it in causal order. The dynamic display synchronization module replaces the display state of the corresponding twin entity and time interval according to the replay result.

[0020] In this embodiment, panoramic spatiotemporal data refers to data records that can be mapped to twin entities, spatial ranges, and temporal locations. The access source can be a data interface already configured on the platform, historical data files, business operation logs, or other data streams that can provide entity state changes, without limiting specific acquisition devices or application scenarios. The platform configures field mapping rules for each type of input data, mapping the original identifier to a unified twin entity identifier, converting the original spatial description into a spatial scope, comparing the original attribute value with the previous valid state to form a state change quantity, and converting the record number, version number, associated object number, or upstream event number in the original record that can indicate the dependencies between the preceding and following states into causal pre-identifiers. When the original record does not contain an explicit pre-identifier, the data event processing module generates a pre-identifier to be confirmed based on the attribute version of the same entity, adjacent spatial states, and existing state transformation relationships, without directly taking the receiving order as the causal order.

[0021] Specifically, each spatiotemporal event is stored using an immutable event record. The event record includes at least the event identifier, data source identifier, associated twin entity identifier, event occurrence time, platform reception time, spatial scope, attribute set, state change quantity, causal precondition identifier, original data summary, and processing version. The state change quantity is represented by an increment relative to the previous valid attribute version. Numerical attributes record old value references and new values, discrete attributes record the previous enumeration state and the next enumeration state, trajectory attributes record the previous spatial location, the next spatial location, and the covered time interval, and set attributes record added members, deleted members, and retained members. The original data summary is used to verify the consistency of repeated access and playback, and the processing version is used to distinguish the event interpretation after the field mapping rules or state transition rules have been updated. Any subsequent corrections are saved as new version relationships without overwriting the original event record.

[0022] Please refer to Figure 1 The spatiotemporal causal ledger establishes logical partitions based on twin entities, and within each logical partition, a stable locating key is formed by the event occurrence time, event version, and append sequence number. The append sequence number only indicates the write position of the ledger and does not participate in the determination of the state sequence. The event records in the ledger form a traceable link through previous version references, subsequent version references, causal pre-references, and related entity references. The state snapshot is only saved as data to accelerate reading, and the snapshot also records the set of events covered by the snapshot and the version identifier of each attribute. When the snapshot is inconsistent with the ledger event, the snapshot is regenerated with the ledger event and version reference, thereby avoiding the use of variable snapshots as the source of event facts. The ledger append operation is committed after all event records, version references, and causal edge candidate records are written, so that subsequent replays can obtain complete pre-recorded data.

[0023] In a causal dependency graph, nodes correspond to spatiotemporal events. Directed edges point from preceding events to subsequent events that reference their states. The establishment of edges simultaneously verifies entity associations, spatial scope, state transitions, and event timing. Let the event be... and The associated twin entities are respectively and The times of the events are as follows: and The spatial domains are respectively and , This indicates whether there is a pre-registered state association between two entities. Indicates an event The processed attribute state, Indicates an event The change in state This represents the deterministic state transition function corresponding to attribute p. Indicates an event The processed attribute state and causal edge decision quantity are defined as follows.

[0024] ; in, This is a conditional indicator operation; the value is 1 if the condition within the parentheses is true, and 0 otherwise. Only then is it established by events Pointing to events Causal edges; for example, events The entity will be at event time 100. The location attribute changes from space tile A to space tile B, event At event time 110, if the same entity is moved from spatial tile B to spatial tile C, the entity association, spatial overlap, state transition, and temporal sequence all hold true. Even if the event The platform received the message later than the event. The aforementioned causal relationships are still determined by the occurrence of events, and the platform uses this to classify events. The event is identified as a late event that can be inserted into the state chain.

[0025] The data event processing module marks events whose occurrence time is earlier than the current entity's committed state time and whose platform reception time is later than the corresponding subsequent event reception time as late events. It also marks events with the same entity, the same attributes, and overlapping time intervals but whose state changes cannot be simultaneously true as conflict events. Late events are marked only to trigger causal admission checks, not direct overwriting. Conflict events are marked only to trigger candidate branch construction, not direct deletion of any record. Causal admission checks start from the preceding state version of the late event, verifying whether it can form a continuous state transition, and checking whether existing subsequent events reference the state version replaced or supplemented by the late event. When a late event can be inserted but does not change the attribute version referenced by any subsequent event, only a historical branch is added to the ledger, and state reversal is not initiated.

[0026] The locally reversible replay module determines the minimum dependency subgraph by propagating the affected attributes along the causal edges. This indicates that there exists a causal dependency graph. arrive A directed path, Indicates the event A set of attributes that can be changed and propagated along a path. Indicates an event Referenced properties This represents the spatial extent of influence accumulated along a directed path. Indicates an event Whether it is an independent evidence boundary, the value of independent evidence boundary is 1, and the value of others is 0. The node set of the minimum dependency subgraph is defined as follows.

[0027] ; In the above expression, an event is entered only if it simultaneously satisfies the following conditions: causal reachability, time no earlier than a late event, reference to the affected attribute, and spatial extents intersect without reaching the independent evidence boundary. For example, if a late event changes the position of entity A at time 100, and two events at time 110 and time 120 consecutively reference that position, and the event at time 130 redetermines the position of entity A by an independent data record and no longer references the aforementioned position version, then the events at time 110 and time 120 enter the minimum dependency subgraph, while the events at time 130 and their successors do not. Based on this, the local reversible replay module only cancels the state increments within the coverage of the aforementioned two events and the late event, without expanding to all historical events or omitting subsequent states that still use the incorrect position as a prerequisite.

[0028] Undo processing is performed in reverse topological order of the least dependent subgraph. The locally reversible replay module reads the old value reference, attribute version reference, spatial slice reference, and associated entity edge reference corresponding to each event, removes the new version formed after the event submission from the current state index, and restores the attribute version referenced before the event submission. During the restoration process, the ledger event is not deleted, but the corresponding version is marked as temporarily ineffective. Replay processing places the late event in a position that meets the event time and preceding version conditions, and then recalculates the state change, output attribute version, and causal edges of the successor event according to the topological order of the least dependent subgraph. If a successor event after replay is the same as the original processing result, the original event identifier is retained and a new processing version is created. If the state change changes, a new attribute version is generated and the original version is registered as a recyclable version.

[0029] The dynamic display synchronization module maintains the correspondence between the twin state version and the display object version. The display object can be an entity primitive, trajectory fragment, attribute marker, spatial tile content, or timeline fragment. After the local reversible playback is completed, the module extracts the affected entity identifier, attribute version range, spatial range, and event time range from the least dependent subgraph and generates a local display repair request. The repair request does not directly clear the entire screen cache, but instead locates the cached items that are simultaneously associated with the entity, spatial range, and time range, converts the replayed attribute state to the new display version, and uniformly replaces it at the screen composition boundary. For unaffected entities and spatial ranges, the original cached version continues to be used. For states that are still in a temporary branch, they are not written to the currently visible display chain.

[0030] In a preferred embodiment, the data event processing module includes a time semantic normalization process and an event version orchestration process. The time semantic normalization process retains the data source time, the event occurrence time, and the platform reception time, respectively, and determines the time offset based on the continuous state records of the same twin entity. The time offset is written into the event time correction field without rewriting the original time field. The event version orchestration process forms an event version key using the twin entity identifier, state attribute identifier, and spatial scope identifier. For new spatiotemporal events with the same event version key, a preceding version reference, a parallel candidate version reference, or a supplementary version reference is established, so that the spatiotemporal causal ledger simultaneously saves the original event order, the corrected event order, and the version evolution relationship.

[0031] The temporal semantic normalization process maintains an independent temporal description for each data source. The data source time is the time carried by the original record, the event occurrence time is the platform's interpretation time of the actual state change location, and the platform reception time is the time when the event enters the access buffer. These three times are stored separately, and any correction only generates an event time correction field and a correction version. For continuous state records of the same twin entity, the platform selects records that correspond to the same state transition in multiple data sources as time anchors. For example, when an entity transitions from state A to state B and the transition result, spatial location, and attribute versions before and after are consistent, the time difference between the records of each data source is registered as the offset observation of that data source. Records that do not have common state transition evidence are not used as time anchors to avoid using reception time to approximate event occurrence time.

[0032] Event version keys are generated by combining twin entity identifiers, state attribute identifiers, and scope identifiers normalized by spatial indexing. Events under the same version key are deduplicated according to their original event identifiers before being entered into version orchestration. When the previous state version of a new event is consistent with the currently effective version and the state transition is reachable, a preceding version reference is established. When a new event and an existing event use the same previous state version but form mutually exclusive subsequent states, a parallel candidate version reference is established. When a new event only supplements a subset of attributes not included in existing events and does not change the values ​​of existing attributes, a supplementary version reference is established. The original event order is saved according to the data source time and the in-source sequence number, the corrected event order is saved according to the corrected event occurrence time and causal precedence relationship, and the version evolution relationship is saved according to the preceding, parallel, and supplementary references. The three types of orders do not overlap with each other.

[0033] In a preferred embodiment, the causal dependency graph generation module extracts the twin entity inheritance relationship, spatial domain overlap relationship, state attribute transfer relationship, and state transition reachability relationship for any preceding and subsequent events to be connected. Causal edges are established only when the subsequent event references the entity state formed by the preceding event and satisfies the corresponding state transition constraints. The causal edges record the referenced state attributes, scope of action, and allowed event time intervals. For late events whose event time falls within the allowed event time interval but whose reception time is later than the subsequent event, causal admission judgment is performed based on the causal edges, and late events that do not satisfy the state transition reachability relationship are written into isolated branches and not merged into the current state chain.

[0034] Entity inheritance relationships are determined by the version chain of twin entities and the mapping table of associated entities. Successive versions of the same entity are considered direct inheritance, while entities with parent-child, composition, reference, or mapping relationships and registered state transit rules are considered associated inheritance. Spatial scope overlap relationships are calculated using a unified spatial index. Point objects are converted into their spatial units, line objects into the set of spatial units they pass through, and face objects into the set of covering spatial units. State attribute transit relationships record which preceding attribute versions were read by subsequent events. State transition reachability is verified by the state transition table or deterministic transition function corresponding to each type of attribute. Causal edges store the preceding event identifier, the following event identifier, the referenced attribute, the overlapping spatial units, the allowed event time interval, and the edge version, so that the corresponding edge can be reconstructed without rewriting the original edge when subsequent rules are changed.

[0035] The allowed event time interval is jointly defined by the determined occurrence time of the preceding event, the determined occurrence time of the subsequent event, and the state transition duration condition. When the candidate occurrence time of a late event falls into this interval, it is further examined whether its previous state can be formed by the preceding event and whether its subsequent state can be referenced by the subsequent event. Late events that satisfy both tests are added to the current state chain and trigger local influence analysis. Late events that only satisfy the forward state transition but cannot form a backward reference closure are entered into the verification branch. Late events that do not satisfy the forward state transition are entered into the isolation branch. The isolation branch retains the original event, correction time, version key, and candidate causal edges. When data that can supplement the preceding state or correct the spatial scope is received later, the causal admission judgment is re-executed.

[0036] In a preferred embodiment, the locally reversible replay module starts with a late event determined by causal admission, searches along the outgoing edges of the causal dependency graph for subsequent events that reference the same state attribute, are in the intersecting space scope, and whose event time is no earlier than the late event, and terminates the search when it encounters a boundary event that has been determined by independent evidence and no longer references the aforementioned state attribute, so as to form a minimal dependency subgraph. The locally reversible replay module calls the state inverse operation records corresponding to each event in the reverse topological order of the minimal dependency subgraph to restore the baseline state, and then resubmits the late event and the subsequent events in the minimal dependency subgraph to the twin state chain in the topological order.

[0037] Edge retrieval employs both attribute constraints and spatial constraints for pruning. Upon traversing each causal edge, it reads the referenced state attribute and its scope of action recorded within the edge, updating the current propagation attribute set and the current cumulative spatial scope to their actual intersection. If a subsequent event only references other attributes of the same entity, or if its spatial scope no longer intersects with the cumulative spatial scope, propagation along that edge ceases. Independent evidence boundaries are boundaries formed by events that do not depend on the aforementioned attribute versions. For example, if an event is directly given a complete attribute state by an independent record and uses a new state version as a prerequisite for subsequent events, the boundary event is retained as its current valid state and is not included in the revocation set. If the boundary event still references a portion of the affected attribute, propagation continues only for the referenced portion, while other attributes retain their original versions.

[0038] State inverse operation records are generated synchronously when an event is first submitted and are bound to the event identifier and processing version. For numeric and enumerated attributes, the inverse operation record saves a reference to the previous attribute version that was replaced. For trajectory attributes, the inverse operation record saves a reference to the trajectory segments that were added, truncated, or connected. For set attributes, the inverse operation record saves the added items, deleted items, and their original version positions. For associated entity edges, the inverse operation record saves the added edges and the removed edges. When restoring the baseline state, the local reversible replay module first removes the derived versions formed by subsequent events, and then restores the previous version and associated edges in reverse topological order, so that when any event is undone, its subsequent events have stopped referencing the corresponding derived state. When resubmitting, the original event data and the current previous version are used for calculation, and old results that have lost their previous conditions are not directly reused.

[0039] In a preferred embodiment, please refer to Figure 2 The temporal semantic normalization process maintains a time correction description for each data source, consisting of stable time anchors and drift intervals. Stable time anchors are jointly determined by consistent state switching records of the same twin entity in different data sources, and drift intervals are generated by the time offset changes between adjacent stable time anchors. When a new spatiotemporal event lacks a reliable event occurrence time, a candidate event time range is generated according to the drift interval where its data source time is located, and the candidate event time range is shrunk using previous version references and subsequent version references. When the shrunk candidate event time range still covers multiple insertable positions, the corresponding spatiotemporal event is established as multiple temporary time branches sharing the same original event identifier.

[0040] Let the data source be q, and the data source times of adjacent stable time anchors be respectively... and The corresponding observation time offsets are respectively and The data source time for the pending events is Time offset within the drift interval and correct event time Determine according to the following formula.

[0041] ; See Figure 4 In the figure, the horizontal axis represents the time sampling sequence number of the data source, ranging from 1 to 321, and the vertical axis represents the time offset, with values ​​ranging from approximately 1.83 to 8.56. The curves correspond to four types of data sources: video perception access, trajectory terminal access, IoT status access, and manual verification access. The legend indicates the data source category corresponding to each curve; the two horizontal reference lines represent different levels of time offset observation thresholds.

[0042] from Figure 4 As can be seen, the IoT status access curve is at its highest point overall, reaching approximately 8.56 at the end, indicating a more significant cumulative offset between the sampling clock of this type of data source and the platform's reference time. The video perception access curve rises from approximately 4.03 to approximately 7.05, the trajectory terminal access curve gradually rises from a low level to approximately 6.39, and while the manual verification access curve is generally low, it also rises to approximately 5.46 in the later stages. The simultaneous upward movement of multiple curves at the end indicates that different data sources require time compensation through anchor point intervals after prolonged operation.

[0043] This figure illustrates the role of the time drift interpolation formula before multi-source events are recorded. Adjacent stable time anchors indicate the start and end offsets of the drift interval, and the curves show the results of continuous calculations for each sampling point within that interval. When the slope of a curve increases, the event time correction amount of its corresponding data source also increases, which will affect the width of the time interval for subsequent candidate events.

[0044] in, For the event Data source time, This is the corrected event time obtained based on the drift interval; for example, if the time offset of data source q is 4 at data source time 100 and 6 at data source time 200, and the data source time of the event to be processed is 150, then... The correction event time is 145; this value is only written to the correction field, and the original data source time of 150 remains unchanged; if there is an inconsistency in the state switching between anchor points, the corresponding interval will be divided into multiple drift intervals, and multiple candidate correction results will be reserved for the event to be processed, and linear extrapolation will not be performed across inconsistent intervals.

[0045] See Figure 5In the figure, the horizontal axis represents the event window number, ranging from 1 to 85, and the vertical axis represents the interval before and after correction, with values ​​ranging from approximately 1.85 to 5.36. The solid line represents the window mean, the dashed line represents the low-order value of the window, and the dotted-dash line represents the high-order value of the window. This figure corresponds to the processing steps in the text where the current drift is subtracted from the data source time to obtain the corrected event time.

[0046] from Figure 5 As can be seen, the window mean curve gradually rises from approximately 3.38 in the early stage to approximately 3.86 in the later stage, the high-value curve rises from approximately 4.91 to approximately 5.36, and the low-value curve rises from approximately 1.85 to approximately 2.36. The three curves maintain a parallel upward trend, indicating that the correction amount for this batch of events is not caused by individual anomalies, but rather by the clock offset trend presented by multiple consecutive windows. The high-value curve maintains a stable distance from the mean curve, indicating that some events consistently fall within a larger correction requirement range, and should be considered an important input for judging late events and expanding the candidate range.

[0047] When the offset observation has a range of values, let the minimum allowable offset within the drift interval be . The maximum allowed offset is The preceding version of the event to be processed occurred at the time of... The subsequent version occurred at the time of Candidate event time interval Calculate according to the following formula.

[0048] ; For example, if the data source time is 150 and the allowed offset range is 4 to 6, then the initial candidate interval is 144 to 146. If the preceding version occurs at time 145 and the following version occurs at time 149, then the intersection result is 145 to 146. The platform only searches for insertable positions within this interval. If 145 and 146 correspond to different but reachable preceding states, the event version orchestration process establishes temporary time branches with the same original event identifier for the two positions, and records the referenced preceding versions and candidate causal edges respectively. After the subsequent data determines the true preceding state, the corresponding branch is retained and other branches are registered as recyclable versions.

[0049] Temporary time branches are isolated from the current state chain. Successor candidate relationships can be formed within a branch, but the current effective state is not replaced until the branch passes the forward reachability and backward closure verification. Multiple temporary time branches with the same original event identifier share the original data digest and data source time, and each has an independent correction event time, previous version reference, and processing version. When a subsequent event can close one of the branches and conflicts with other branches, the closing branch is connected to the current state chain, and the other branches are retained until the set ledger cleanup conditions are met. When subsequent evidence indicates that the original record itself is invalid, each temporary time branch is marked as invalid, and the original record is still stored in the ledger for traceability.

[0050] In a preferred embodiment, please refer to Figure 3 The isolated branches are organized according to conflict event groups. Each conflict event group consists of candidate events that point to the same twin entity, have the same state attribute, and have overlapping event time intervals. The causal dependency graph generation module calculates the state transition reachable path between each candidate event and its predecessor event, the state reference closed path between each candidate event and its successor event, and the spatially consistent path between each candidate event and the associated twin entity event. Candidate events that simultaneously form forward reachability, backward closure, and spatial consistency are added to the current state chain. Candidate events that are not added to the current state chain retain their original causal edges and version references, and the addition decision is re-executed when a new state reference closed path is formed in a subsequent event.

[0051] In the conflict incident group, set This indicates whether the reachable path for the forward state transition is valid. This indicates whether a backward state reference to a closed path is valid. Indicates whether a spatially consistent path exists between the associated twin entity event and the virtual twin event. All three are binary quantities, taking the value 1 if true and 0 if false. (Candidate access quantity) The definition is as follows.

[0052] ; when At this time, a candidate event simultaneously possesses traceable preceding states, verifiable subsequent references, and consistent spatial relationships; for example, if two candidate events both point to the location attribute of entity A and cover times 145 to 146, candidate event A can be derived from its preceding location B, and its subsequent trajectory event references its output location, while also maintaining consistent spatial relationships with the associated entities, then... Candidate event A Although candidate event B can be obtained from the preceding state, its output position cannot be closed by the subsequent trajectory. Candidate event B The platform accesses candidate event A and retains candidate event B in the conflict event group.

[0053] When there are multiple conflict event groups When considering candidate events, the platform does not directly adjudicate based on a fixed priority of the data source. Instead, it establishes separate, verifiable state branches. These branches share the baseline version before the conflict and independently generate subsequent causal edges. If a subsequent event forms a closed state reference path with only one branch, that branch is accessed and the other branches are reclaimed. If a subsequent event remains closed for multiple branches, the parallel candidate state is maintained, but its entry into the current display chain is restricted. All existing causal edges, version references, and spatially consistent paths of events not accessed are retained. When a new event forms a new backward closed path or corrects the spatial state of associated entities, the causal dependency graph generation module recalculates. , and This is to avoid a one-off ruling that could undermine subsequent recovery conditions.

[0054] See Figure 6 In the figure, the horizontal axis represents the aggregation window number, ranging from 1 to 60, and the vertical axis represents the acceptance score, with values ​​ranging from approximately 0.17 to 1.00. The solid line represents the mean of the acceptance score window, the dashed line represents the forward reachability ratio, and the dotted-dash line represents the spatial consistency ratio. This figure corresponds to the process in the text where forward state transition reachability, backward state reference closure, and spatial consistency paths are used to determine whether a candidate event can enter the formal state chain.

[0055] from Figure 6 As can be seen, the spatial consistency ratio remained high for most windows, with a mean of approximately 0.96, indicating that the candidate branches were generally stable in terms of spatial relationships. The mean forward reachability ratio was approximately 0.53, significantly lower than the spatial consistency ratio, suggesting that the main factor limiting candidate branch acceptance was not spatial conflict, but rather the ability of preceding states to continuously reach the candidate state. The mean acceptance score reached approximately 0.67 in windows 2 and 3, then dropped to approximately 0.17 in windows 29 and 41, indicating a clear stratification in the quality of candidate branches.

[0056] In a preferred embodiment, the state inverse operation record is associated with the event state increment, including the attribute version identifier before the increment, the reference of the replaced value, the spatial slice reference, and the reference of the associated entity edge. After forming the minimum dependency subgraph, the local reversible replay module groups the successor events with a common preceding state version into parallel replay groups, establishes temporary state branches for different parallel replay groups, and performs branch merging based on attribute version continuity, spatial slice mutual exclusion, and associated entity edge consistency after each temporary state branch has been replayed. For temporary state branches with overlapping writes that cannot satisfy attribute version continuity, they are retained until the corresponding conflicting event group has completed the access determination before merging continues.

[0057] The state inverse operation record and the state increment use the same attribute path encoding. When the increment is written to an attribute path, the inverse operation record saves the attribute version identifier before the path was written and the reference to the replaced value. When the state increment is written to a trajectory or region attribute, the inverse operation record saves the affected spatial slice and the reference to the original slice content. When the state increment adds, removes, or changes the associated entity edge, the inverse operation record saves the edge type, starting entity, ending entity, and the previous edge version. Before replay, the local reversible replay module verifies that the baseline version referenced by the inverse operation record still exists in the ledger or version storage. If the baseline version has been archived, the required version is restored according to the ledger event chain before the inverse operation is performed to avoid using missing old values ​​for reverse derivation.

[0058] Parallel replay groups are divided according to a common preceding state version and a set of independent outgoing edges. Events within a group can be computed in their respective temporary state branches. When there are causal edges between groups, they are still processed in topological order. Let the temporary state branches be... and , and This represents the attribute version chain of each branch. and This represents the set of write space slices for each branch. and This indicates the version relationship between branches on the common entity edge. This indicates that two version chains can be continuously connected from a common predecessor version; branch merging decision quantity. The definition is as follows.

[0059] ; when At that time, two branches with continuous version relationships, non-overlapping space writes, and consistent associated entity edges can be merged into the same state chain; for example, branches Modify the position attributes of space slice A, branching. Modify the state attributes of spatial slice B. Both are derived from the same previous version. If slice A and slice B do not overlap and the versions of the associated entity edges are consistent, then all three indicators are set to 1. If the two branches are written to spatial slice A at the same time and generate different attribute versions, then the second indicator is set to 0. The platform retains the two temporary state branches and writes the overlapping parts to the corresponding conflict event group, without performing an overwrite merge.

[0060] When merging branches, the platform generates a new merged version based on the common preceding version. It registers attribute versions and spatial slice references according to the event topology order of each temporary state branch, without re-copying the unchanged state content. The consistency of associated entity edges is determined by comparing edge type, starting entity, ending entity, and edge preceding version. If two branches make opposite changes to the same edge, they are considered inconsistent and enter conflict handling. Temporary state branches that have completed merging retain the processing version and event mapping, which facilitates the re-triggering of local replays by subsequent late events. Branches that have not completed merging do not participate in the generation of the current state snapshot, nor do they submit visible patches to the dynamic display synchronization module.

[0061] In a preferred embodiment, the dynamic display synchronization module maintains spatial tile cache and temporal segment cache corresponding to the twin state version of the display screen, and maps the least dependent subgraph to a display patch list consisting of twin entity identifiers, attribute version ranges, spatial tile sets, and temporal segment sets. The dynamic display synchronization module only invalidates cache items that overlap with the display patch list, converts the replayed state increment into local display patches arranged in chronological order, and inserts continuous state segments from the previous valid state to the next valid state between adjacent patches of the same twin entity. Cache items that do not overlap with the display patch list retain their original version and participate in subsequent screen composition.

[0062] Spatial tile caches are located using a unified spatial index identifier and a display hierarchy identifier, while time segment caches are located using twin entity identifiers, attribute paths, start event times, and end event times. Each cache entry records the set of twin attribute versions it references. Let the spatial tile be g, the time segment be h, and the set of minimal dependency subgraph nodes be... Regarding the events The spatial scope and event time are denoted as follows: and The time of the lateness event is Show the repair list The definition is as follows.

[0063] ; For example, if the minimum dependency subgraph contains events with times from 100 to 120 and a spatial scope covering both tile A and tile B, and the time segment cache contains four segments: 90 to 105, 105 to 115, 115 to 130, and 130 to 150, then the first three segments intersect with 100 to 120 and enter the patch list, while 130 to 150 does not. Spatial tile C does not intersect with any affected spatial scope and does not enter the patch list. The dynamic display synchronization module only invalidates the cached items formed by the combination of tile A, tile B, and the first three time segments, while other cached items continue to participate in the image composition.

[0064] The partial display patch includes the twin entity identifier, attribute path, previous display version, next display version, applicable spatial tile, applicable time segment, and patch submission order. When the replay result changes the trajectory endpoint or attribute state, the module checks whether the ending state of the previous patch and the starting state of the next patch are consistent based on the time boundaries of adjacent patches. If they are inconsistent and the two states belong to the same continuous attribute, a continuous state segment from the previous valid state to the next valid state is inserted. The continuous state segment is only used to connect the verified adjacent states and does not infer additional changes beyond the range of the two ends of the state. If the attribute is a non-continuous discrete state, a version switch is performed at the time boundary of the correction event, and no intermediate value is generated. Patches enter the invisible composition buffer in chronological order, and replace the current display version after completing the version verification.

[0065] In a preferred embodiment, the locally reversible replay module sets replay checkpoints in each temporary state branch, identified by a set of attribute versions, a set of spatial slices, and a set of committed events. When a replay event reaches an existing replay checkpoint, the module compares the state increment summary and causal prereference of the corresponding event. If they match, the module reuses the existing state chain after the replay checkpoint and terminates the replay of the corresponding temporary state branch. If they do not match, the module generates a new temporary state branch from the earliest checkpoint corresponding to the differing attribute version and registers the replaced existing state chain as a recyclable version until the new temporary state branch releases the recyclable version after passing the attribute version continuity and associated entity edge consistency checks.

[0066] Replay checkpoints are generated at the event commit boundary. The checkpoint content includes an attribute version set, a spatial slice set, a committed event set, a state increment summary, a causal before-reference set, and a checkpoint before-reference. The state increment summary is generated by encoding the event identifier, processing version, attribute path, increment content, and spatial slice reference in a stable order, and is used to determine whether the new replay result is consistent with the existing result. Let the new replay checkpoint be m, and the existing checkpoint be n, with the corresponding state increment summaries as follows: and The causal front reference sets are respectively and The attribute version sets are respectively and Checkpoint reuse judgment quantity The definition is as follows.

[0067] ; when When the new replay reaches the checkpoint, the state content, causal source, and attribute version are consistent with the existing state chain. The locally reversible replay module connects the temporary state branch to the existing state chain after the checkpoint and stops further calculation. For example, if the state increment summary of the old and new checkpoints is the same, the causal pre-references both refer to event A and event B, and the attribute version set is both position version 5 and state version 8, then all three indicators are set to 1. If the summary is the same but the causal pre-references are different, the second indicator is set to 0, the platform does not reuse the existing state chain, and continues replaying from the earliest checkpoint that can cover the different pre-references.

[0068] Reclaimable versions remain readable until the new temporary state branch completes verification, but are no longer used as the entry point for the current state chain. Reclaimable versions record the reason for replacement, the replacement branch identifier, the associated display version, and the latest reference checkpoint. They are not released if they are still referenced by temporary state branches, display patches, or historical query tasks. After the new temporary state branch passes the attribute version continuity and associated entity edge consistency verification, the platform releases the old state content that is not referenced by any checkpoints or display versions, while retaining ledger events, version relationships, and summary information. If the new branch verification fails, the new branch is revoked and the reclaimable version is restored as the current state chain. Therefore, verification failure will not cause the loss of existing usable states.

[0069] In a preferred embodiment, the dynamic display synchronization module attaches a display version identifier corresponding to the replay checkpoint to each local display patch and establishes a patch commit chain according to the causal order of the same twin entity. When a new temporary state branch is generated during replay, the corresponding local display patch is first written to the invisible display branch. After the temporary state branch passes the attribute version continuity, spatial slice mutual exclusion and associated entity edge consistency checks, the invisible display branch is atomically switched with the current patch commit chain. When the temporary state branch is registered as a recyclable version, the local display patch associated with the recyclable version that has not yet completed the atomic switch is deleted, and the most recent valid display version referenced by the current screen is retained.

[0070] The display version identifier consists of the twin entity identifier, the replay checkpoint identifier, the attribute version set summary, and the patch number. The patch commit chains of the same twin entity are connected in causal order, not in the order of patch arrival. Invisible display branches use independent chain head records. Their local display patches can complete spatial tile synthesis, temporal segment connection, and display object version verification, but will not be referenced by the current screen. Atomic switching updates the chain head of the current patch commit chain, the display version reference of the affected cached item, and the corresponding twin state checkpoint reference at the same commit boundary. The most recent valid display version continues to be displayed until the switch is completed. If the switch fails, it reverts to the original chain head and discards the new chain head reference that has not been committed.

[0071] In practical applications, the platform receives consecutive position events of entity A at times 100, 110, and 120. Event 100 arrives after event 120 due to transmission delay. The data event processing module retains the data source time, event occurrence time, and platform reception time for each event, and establishes a causal pre-reference for event 100 that matches the previous position version of event 110. The causal dependency graph generation module verifies the entity association, spatial overlap, state transition, and event time between event 100 and event 110, establishes causal edges, and then verifies the reference relationship between event 110 and event 120. The locally reversible playback module determines that events 110 and 120 belong to the minimum dependency subgraph along the outgoing edges. When it encounters event 130, which directly gives the complete position from an independent record, it stops propagation and performs the inverse operation from event 120 to event 110 to restore the baseline state before the insertion of event 100.

[0072] After event 100 is inserted, the platform resubmits according to the topological order of events 100, 110, and 120. If the state increment of event 110 changes from the original spatial tile A to spatial tile C to spatial tile B to spatial tile C, a new position attribute version is generated and its causal edges are updated. Event 120 continues to reference the new version of event 110. When the replay reaches the checkpoint after event 120, if the state increment summary, causal prereference, and attribute version set are consistent with the existing checkpoint, the existing state chain is connected and subsequent replays are stopped. The dynamic display synchronization module generates a patch list covering event times 100 to 120 and related spatial tiles, replaces the corresponding trajectory fragment in the invisible display branch, and keeps the display version after event 130 unchanged. After completing the state branch verification, the patch submission chain is atomically switched.

[0073] During program execution, ledger appending, causal edge updating, state version committing, and replay checkpoint generation are associated with the same transaction boundary or recoverable commit record. If an event record has been written but the state version has not yet been committed, the recovery program regenerates the state increment based on the ledger location key and verifies the original data digest. If the state version has been committed but the display patch has not yet completed the atomic switch, the dynamic display synchronization module maintains the most recent valid display version and rebuilds the invisible display branch. If the temporary state branch verification fails, the locally reversible replay module removes the current state entry of the new branch and restores the reclaimable version. The relevant unswitched display patches are deleted synchronously. This ensures that the spatiotemporal causal ledger, twin state chain, replay checkpoint, and dynamic display version still point to the same confirmed event set after recovery.

Claims

1. A panoramic spatiotemporal data twin and dynamic display platform for the Sky Eye, characterized in that, It includes a data event processing module, a spatiotemporal causal ledger, a causal dependency graph generation module, a locally reversible playback module, and a dynamic display synchronization module; The data event processing module encapsulates the accessed panoramic spatiotemporal data into spatiotemporal events with event occurrence time, platform reception time, spatial scope, associated twin entity, state change quantity, and causal pre-identification. The spatiotemporal causal ledger appends the spatiotemporal events according to the twin entity; The causal dependency graph generation module constructs directed dependency relationships between events based on entity association, overlapping spatial domains, and state transition constraints. After the late event passes the causal admission judgment, the local reversible replay module determines the minimum dependent subgraph affected by the late event, cancels the state increment corresponding to the minimum dependent subgraph, and replays it in causal order. The dynamic display synchronization module replaces the display status of the corresponding twin entity and time interval based on the replay results.

2. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 1, characterized in that, The data event processing module includes a time semantic normalization process and an event version orchestration process; The time semantic normalization process retains the data source time, event occurrence time, and platform reception time respectively, and determines the time offset based on the continuous state records of the same twin entity. The time offset is written into the event time correction field without rewriting the original time field. The event version orchestration process uses twin entity identifiers, state attribute identifiers, and spatial scope identifiers to form event version keys. For new spatiotemporal events with the same event version key, a preceding version reference, a parallel candidate version reference, or a supplementary version reference is established, so that the spatiotemporal causal ledger can simultaneously save the original event order, the corrected event order, and the version evolution relationship.

3. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 1, characterized in that, The causal dependency graph generation module extracts the twin entity inheritance relationship, spatial scope overlap relationship, state attribute transfer relationship and state transition reachability relationship for any preceding and subsequent events to be connected. Causal edges are established only when the subsequent event references the entity state formed by the preceding event and satisfies the corresponding state transition constraints. The causal edge records the referenced state attributes, scope of action, and allowed event time intervals; For late events whose event time falls within the allowed event time interval but whose reception time is later than the subsequent event, the causal admission determination is performed according to the causal edge, and late events that do not satisfy the state transition reachability relationship are written into the isolated branch instead of being merged into the current state chain.

4. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 1, characterized in that, The locally reversible replay module starts with the late event determined by the causal admission criteria, searches along the outgoing edges of the causal dependency graph for subsequent events that reference the same state attribute, are in the intersecting space scope, and whose event time is no earlier than the late event, and terminates the search when it encounters a boundary event that has been determined by independent evidence and no longer references the aforementioned state attribute, so as to form a minimum dependency subgraph. The locally reversible replay module calls the state inverse operation records corresponding to each event in the reverse topological order of the minimum dependency subgraph to restore the baseline state, and then resubmits the late event and the subsequent event in the minimum dependency subgraph to the twin state chain in the topological order.

5. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 2, characterized in that, The time semantic normalization process maintains a time correction description for each data source consisting of stable time anchors and drift intervals. The stable time anchors are jointly determined by the consistent state switching records of the same twin entity in different data sources, and the drift intervals are generated by the time offset changes between adjacent stable time anchors. When a new spatiotemporal event lacks a reliable event occurrence time, a candidate event time range is generated according to the drift interval where its data source time is located, and the candidate event time range is narrowed using previous version references and subsequent version references; When the time range of the candidate events after shrinking still covers multiple insertable locations, the corresponding spatiotemporal events are established as multiple temporary time branches that share the same original event identifier.

6. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 3, characterized in that, The isolated branches are organized according to conflict event groups. Each conflict event group consists of candidate events that point to the same twin entity, have the same state attribute, and have overlapping event time intervals. The causal dependency graph generation module calculates the state transition reachable path between each candidate event and its predecessor event, the state reference closed path between each candidate event and its successor event, and the spatially consistent path between each candidate event and its associated twin entity event. The candidate event that simultaneously forms forward reachability, backward closure and spatial consistency is then connected to the current state chain. Candidate events that are not connected to the current state chain retain their original causal edges and version references, and the connection determination is re-executed when a new state reference closure path is formed by subsequent events.

7. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 4, characterized in that, The state inverse operation record is associated with both the event state increment and includes the attribute version identifier before the increment is applied, the reference to the replaced value, the spatial slice reference, and the reference to the associated entity edge. After forming the minimum dependency subgraph, the local reversible replay module groups successor events with a common preceding state version into parallel replay groups, establishes temporary state branches for different parallel replay groups, and performs branch merging based on attribute version continuity, spatial slice mutual exclusion, and associated entity edge consistency after each temporary state branch has completed replay. For temporary state branches with overlapping writes that cannot meet the attribute version continuity requirement, retain them until the corresponding conflict event group completes the access determination before continuing to merge.

8. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 1, characterized in that, The dynamic display synchronization module maintains the spatial tile cache and time segment cache corresponding to the twin state version of the display screen, and maps the minimum dependency subgraph to a display patch list consisting of twin entity identifiers, attribute version ranges, spatial tile sets and time segment sets; The dynamic display synchronization module only invalidates cached items that overlap with the display patch list, converts the replayed state increment into local display patches arranged in chronological order, and inserts continuous state segments from the previous valid state to the next valid state between adjacent patches of the same twin entity. Cache items that do not overlap with the patch list shown will retain their original version and participate in subsequent screen composition.

9. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 7, characterized in that, The locally reversible replay module sets replay checkpoints in each temporary state branch, which are jointly identified by the attribute version set, the spatial slice set, and the committed event set. When a replay event reaches an existing replay checkpoint, it compares the state increment summary and causal prereference of the corresponding event. When the two are consistent, the existing state chain after the replay checkpoint is reused and the replay of the corresponding temporary state branch is terminated. When the two are inconsistent, a new temporary state branch is generated from the earliest checkpoint corresponding to the difference attribute version, and the existing state chain that was replaced is registered as a recyclable version until the new temporary state branch releases the recyclable version after passing the attribute version continuity and associated entity edge consistency checks.

10. The Sky Eye panoramic spatiotemporal data twin and dynamic display platform according to claim 9, characterized in that, The dynamic display synchronization module adds a display version identifier corresponding to the replay checkpoint to each local display patch, and establishes a patch submission chain according to the causal order of the same twin entity. When a new temporary state branch is generated during the replay process, the corresponding local display patch is first written to the invisible display branch. After the temporary state branch passes the checks of attribute version continuity, spatial slice mutual exclusion and associated entity edge consistency, the invisible display branch is atomically switched with the current patch commit chain. When a temporary state branch is registered as the recyclable version, delete the local display patch associated with the recyclable version that has not yet completed an atomic switch, and retain the most recent valid display version referenced by the current screen.

Images