A spatiotemporal narrative map generation method and system and a storage medium

Abstract

The application relates to the field of space-time data processing, and provides a space-time narrative map generation method and system and a storage medium, wherein deep semantic understanding ability of a large language model (LLM) is innovatively integrated, space-time knowledge is formally represented, a reliable reasoning and checking mechanism is introduced, a verified structured space-time knowledge graph is generated, and finally a complete reasoning chain is visually presented by using an interactive map. Compared with a traditional method, the core advantage of the application lies in that reliable and real-time updating of the space-time knowledge graph is realized, the reasoning process is transparent and intelligent, the reliability of space-time decision support is greatly improved, and the depth and efficiency of information transmission are improved.

Description

Technical Field

[0001] This invention relates to the field of spatiotemporal data processing technology, and more specifically, to a spatiotemporal narrative map generation method, system, and storage medium. Background Technology

[0002] In the field of smart cities, spatiotemporal big data is being used in an increasing number of scenarios, such as traffic flow monitoring, public safety early warning, and environmental quality analysis. However, these applications still face significant bottlenecks in terms of intelligent analysis and decision-making: the core issue is how to quickly and accurately identify the spatiotemporal evolution patterns, causal relationships, and development trends of events from real-time, diverse, and formatted data.

[0003] Traditional Geographic Information Systems (GIS) can process static spatial data, such as map layers of fixed areas and landmark locations. However, transforming this static data into dynamic and easily understandable analytical conclusions based on credible reasoning logic has always been a key challenge in improving decision-making efficiency and public communication capabilities.

[0004] Story maps are an effective narrative tool that uses text, images, maps, and other media to construct geographically relevant narrative content, helping non-technical users understand complex events, such as illustrating the spread of a natural disaster in a region. However, existing story map creation methods have significant shortcomings: they mostly rely on manual pre-analysis of scenarios and design of event flows, using fixed linear expert rules for data analysis, failing to integrate heterogeneous information in real time, and lacking in-depth, reliable reasoning capabilities.

[0005] Although a few cases now use AIGC models to assist in processing, when relying solely on large reasoning models, even if the thought process can be output, the reasoning basis is still opaque like a "black box." It is impossible to explain the reasoning process in a clear, intuitive, and traceable way, which leads to the "credibility" of the conclusions being frequently questioned.

[0006] To build a truly credible and dynamic framework for spatiotemporal narrative analysis, a more intelligent and reliable method is urgently needed. This method must not only be able to deeply understand the complex spatiotemporal context described by natural language and automatically extract key spatiotemporal entities and logical relationships, but also have a core mechanism to verify the accuracy and logical consistency of the extracted information, and finally visually present the verified reasoning chain on a map.

[0007] Traditional methods for constructing spatiotemporal knowledge graphs mostly rely on static data and manual configuration, making them unsuitable for real-time spatiotemporal narrative scenarios. This limitation is particularly pronounced in emergency decision-making (such as emergency rescue) and complex analysis (such as assessing regional economic development trends): the analytical conclusions provided are often delayed or lack credibility. Summary of the Invention

[0008] This invention addresses the technical problems existing in the prior art by providing a method, system, and storage medium for generating spatiotemporal narrative maps.

[0009] According to a first aspect of the present invention, a method for generating a spatiotemporal narrative map is provided, comprising:

[0010] The structured extraction module integrates a large language model to parse the input unstructured data, extract entities and relationships from the unstructured data, output them in a structured form and verify them to generate a spatiotemporal knowledge graph.

[0011] A reasoning mechanism based on formal rules is introduced to perform fact verification, relational reasoning, and contradiction testing on entities and relations in the spatiotemporal knowledge graph, generating a credible event reasoning chain;

[0012] Key spatiotemporal information is extracted from the verified spatiotemporal knowledge graph through multi-turn dialogue, and the key spatiotemporal information is filled into the story map configuration file. The configuration template of the story map is generated in a structured output manner.

[0013] The configuration information in the configuration template is mapped to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map.

[0014] According to a second aspect of the present invention, a spatiotemporal narrative map generation system is provided, comprising:

[0015] The first generation module is used to parse the input unstructured data based on the structured extraction module and the large language model, extract the entities and relationships in the unstructured data, output them in a structured form and verify them, and generate a spatiotemporal knowledge graph.

[0016] The verification module is used to introduce a reasoning mechanism based on formal rules to perform fact verification, relation reasoning and contradiction testing on entities and relations in the spatiotemporal knowledge graph, and generate a credible event reasoning chain.

[0017] The second generation module is used to extract key spatiotemporal information from the verified spatiotemporal knowledge graph in the form of multi-turn dialogue, fill the key spatiotemporal information into the story map configuration file, and generate the configuration template of the story map in a structured output manner.

[0018] The third generation module is used to map the configuration information in the configuration template to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map.

[0019] According to a third aspect of the present invention, an electronic device is provided, including a memory and a processor, wherein the processor is configured to implement the steps of a spatiotemporal narrative map generation method when executing a computer management program stored in the memory.

[0020] According to a fourth aspect of the present invention, a computer-readable storage medium is provided, on which a computer management class program is stored, wherein the computer management class program, when executed by a processor, implements the steps of a spatiotemporal narrative map generation method.

[0021] This invention provides a method, system, and storage medium for generating spatiotemporal narrative maps. By innovatively integrating the deep semantic understanding capabilities of Large Language Models (LLM), it formally represents spatiotemporal knowledge, introduces a reliable reasoning and verification mechanism, generates a verified structured spatiotemporal knowledge graph, and finally visualizes the complete reasoning chain using an interactive map. Compared with traditional methods, the core advantages of this invention lie in achieving reliable and real-time updates of the spatiotemporal knowledge graph, as well as transparency and intelligence in the reasoning process, significantly improving the reliability of spatiotemporal decision support, and enhancing the depth and efficiency of information transmission. Attached Figure Description

[0022] Figure 1 A flowchart of a spatiotemporal narrative map generation method provided in one embodiment of the present invention;

[0023] Figure 2 This is a flowchart illustrating the structure extraction module according to an embodiment of the present invention;

[0024] Figure 3 This is a schematic diagram of entity extraction by the structured extraction module according to an embodiment of the present invention;

[0025] Figure 4 This is a flowchart illustrating the connection between edges and nodes in a structured module according to an embodiment of the present invention.

[0026] Figure 5 This is a diagram illustrating the content saved in the graph database management module.

[0027] Figure 6 This is a complete flowchart of an embodiment of the present invention for automating the configuration of story map files;

[0028] Figure 7 This is a structural block diagram of a spatiotemporal narrative map generation system provided in one embodiment of the present invention;

[0029] Figure 8 A schematic diagram of the hardware structure of a possible electronic device provided by the present invention;

[0030] Figure 9 This is a schematic diagram of the hardware structure of a possible computer-readable storage medium provided by the present invention. Detailed Implementation

[0031] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention. In addition, the technical features of the various embodiments or individual embodiments provided by the present invention can be arbitrarily combined with each other to form feasible technical solutions. Such combinations are not constrained by the order of steps and / or structural composition patterns, but must be based on the ability of those skilled in the art to implement them. When the combination of technical solutions is contradictory or cannot be implemented, it should be considered that such a combination of technical solutions does not exist and is not within the scope of protection claimed by the present invention.

[0032] Existing technologies face three main technical challenges in addressing the generation of automated and intelligent spatiotemporal narratives:

[0033] (1) How to accurately understand and extract user intent from multi-turn dialogues, and formalize unstructured narratives into structured spatiotemporal event chains.

[0034] In multi-turn natural language dialogues, users' narrative intentions are typically multi-layered, non-linear, and dynamically changing. One of the core technical challenges of this invention is how to accurately identify and extract key information from these dialogues, such as multiple times (including relative time), multiple locations (relative positions), multiple events (including causal relationships), and multiple subjects (including referential resolution), and then transform this information into a structured spatiotemporal event chain that is machine-understandable and reasonable. This requires the model not only to understand the context, distinguish between facts and opinions, and accurately extract spatiotemporal elements, but also to map these elements to a unified geographic ontology (e.g., mapping "the gate of a middle school" to the category "entrance / exit of educational facilities") to avoid information loss or semantic ambiguity. Only in this way can the generated event chain effectively support subsequent reliable reasoning and map configuration.

[0035] (2) How to dynamically construct, update and verify the spatiotemporal knowledge graph during the interaction between the user and the intelligent agent, establish a reliable reasoning mechanism, and ensure the integrity and logical consistency of the narrative.

[0036] As user interaction with the intelligent agent deepens, the content of spatiotemporal events will continuously be supplemented and changed. The second technical challenge of this invention is how to efficiently and accurately integrate this new information into the existing knowledge graph and synchronously update the graph structure. While directly using a Large Language Model (LLM) to extract information is fast, the "illusion" problem of LLM can lead to factual errors in the knowledge graph, thus affecting the credibility of subsequent event chains. Therefore, this invention needs to establish a reliable reasoning and verification mechanism: in a multi-turn interaction environment, the model must not only be able to dynamically extract and update spatiotemporal information from historical data (previous dialogue content) and real-time data (current dialogue input), but also be able to verify and reason about newly generated knowledge using pre-defined semantic rules (such as GeoSPARQL rules) to ensure the completeness, reliability, and logical consistency of the narrative content. This is the foundation for achieving "reliable reasoning." This mechanism is the cornerstone of achieving "reliable reasoning."

[0037] (3) How to automatically map the verified event chain into executable interactive multi-scene map configuration code (there may be multiple geographical scenes in the narrative, involving different spatial ranges and geographical objects) to realize spatiotemporal visualization and spatiotemporal traceability of the reasoning process.

[0038] The third key challenge of this invention is how to accurately and automatically transform event chains containing complex causal and spatiotemporal relationships into executable map configuration code, and how this code can clearly present the spatiotemporal reasoning process. This requires the generated configuration code to faithfully reflect the credible reasoning results in the knowledge graph, and to respond in real time to user modifications to the narrative focus (for example, if a user wants to "focus on the coverage area of ​​the diversion measures," the code must be able to quickly adjust the map display content), achieving high accuracy in visualization, interactivity, and traceability.

[0039] Based on this, see Figure 1 The present invention provides a flowchart of a spatiotemporal narrative map generation method according to one embodiment, the method comprising:

[0040] Step 1: Based on the structured extraction module and the large language model, the input unstructured data is parsed, entities and relationships in the unstructured data are extracted, output in a structured form and verified, and a spatiotemporal knowledge graph is generated.

[0041] In one embodiment of the present invention, the step of parsing the input unstructured data based on the structured extraction module and the fusion of a large language model, extracting entities and relationships from the unstructured data, outputting them in a structured form and verifying them, and generating a spatiotemporal knowledge graph includes:

[0042] Based on the natural language understanding capabilities of the Large Language Model (LLM), the system performs preliminary parsing of the input unstructured data, integrating the text content, timestamps, and custom templates into a context object.

[0043] Based on the context object, the context engineering designed based on the large language model outputs structured information containing entities and relationships identified from the context object, according to the format requirements of the custom template.

[0044] The system verifies whether the output structured information conforms to the predefined JSON data syntax rules. If it does not conform, it automatically requests the Large Language Model (LLM) to regenerate the structured information until it passes the verification. If it conforms, it directly outputs the structured information.

[0045] Entities and relationships are extracted from the structured information and mapped onto a predefined ontology to generate a spatiotemporal knowledge graph.

[0046] Understandably, the goal of this step is to transform user-input multi-source heterogeneous data (text, dialogue, JSON, etc.) into machine-readable, logically rigorous formal knowledge. This embodiment of the invention employs a novel structured extraction module that integrates the deep semantic parsing capabilities of the Large Language Model (LLM) with formal ontology constraints, achieving a precise mapping from unstructured information to a structured knowledge graph.

[0047] Figure 2 The flowchart of the novel structured extraction module is shown, which extracts entities (nodes) and relations (edges) from input unstructured data. This process is completed automatically by the structured extraction module, eliminating the need for manual element extraction by the user and achieving full automation of entity and relation extraction. The process is broken down into the following steps:

[0048] (1) Data import and verification:

[0049] The structured data extraction module supports various data types, such as plain text (EpisodeType.text), conversational messages (EpisodeType.message), and structured data (EpisodeType.json). After import, the system verifies the data and assigns a unique identifier (group_id) to each batch, serving as the basis for knowledge tracing.

[0050] (2) Preliminary entity and relation extraction based on LLM:

[0051] This step leverages the powerful Natural Language Understanding (NLU) capabilities of LLM to perform preliminary parsing of the input text. For example, consider the text: "At 3:10 AM, latitude 35.549393°N, longitude 139.779839°E, the ground maintenance team at (an airport) reported that two international flights experienced unstable fuel pressure during taxiing..."

[0052] Step 1: Context Integration. Integrate text content, timestamps, custom Prompts (custom templates), etc., into a single context object.

[0053] Step 2: LLM Invocation. LLM, combined with carefully designed context engineering, is instructed to output its recognized (e.g., "airport", "unstable fuel pressure") and relationships (e.g., "report") in a specific JSON format.

[0054] Step 3: Format Validation. The system automatically checks whether the LLM output conforms to the predefined JSON data syntax rules. If it does not conform, it will automatically request the Large Language Model (LLM) to be regenerated until it passes the validation. This step ensures the stability of subsequent processing flows.

[0055] Step 4: Preliminary Extraction. After verification, the system extracts preliminary entities (nodes) and relationships (edges), such as the node "a certain airport", the node "unstable fuel pressure", and the relationship "report" connecting them.

[0056] The entity extraction process can be found in the following document. Figure 3 As shown, the main steps include:

[0057] 1. Spatiotemporal event extraction.

[0058] This invention employs a novel structured extraction module. When a user provides source knowledge, this module can automatically extract important information such as time, event, subject, location, and position information from the source knowledge. Users no longer need to manually extract these elements, achieving fully automated entity relationship extraction. This structured extraction module consists of the following parts:

[0059] 1.1 Data Import:

[0060] The structured extraction module supports three main data types: plain text (EpisodeType.text), used to store natural language content such as articles, transcripts, or documents; messages (EpisodeType.message), suitable for recording conversation content such as chat logs, emails, or conversations; and JSON (EpisodeType.json), which parses structured data (such as API responses or log files) and transforms it into easily understandable natural language summaries. Each type of plot can be flexibly applied according to specific needs, facilitating the processing of content in different formats and unified management.

[0061] 1.2 Data Validation:

[0062] After successful data import, a series of configuration and validation operations are required. For example, it's necessary to verify whether the input text is JSON, text, or message, which is crucial for subsequent operations. Then, the data needs to be labeled with a `group_id`, a unique identifier for that data, which is an important marker that will be saved in the knowledge graph management module.

[0063] 1.3 Entity Extraction:

[0064] For example, at 3:10 AM, at 35.549393°N, 139.779839°E, the ground maintenance team at (an airport) reported that two international flights experienced unstable fuel pressure during taxiing. The monitoring platform immediately marked the location of the high-risk hangar on the map and retrieved the meteorological conditions of the past 24 hours, indicating that temperature changes may have amplified the risk.

[0065] Step 1: Determine the type of input data. Three data types are currently supported: text, message, and json.

[0066] Step 2: Based on the input text, integrate and process the text data to form a context object, which includes the data type, timestamp, custom prompt, etc. The data structure of the context object is as follows:

[0067] context = {text content, (contend); timestamp, (timestamp); entity type, (entity.type); text type, (contend.type); custom template, (custom_prompt)}.

[0068] Step 3: Combine the large language model LLM with the prompt project output, and perform structured output according to the requirements of the prompt project. The structured output template is as follows:

[0069] { “extracted_entities”: [ { “name”: “extracted entity content”, “entity_type_id”: entity id}, { “name”: “extracted entity content”, “entity_type_id”: entity id} ]}.

[0070] Step 4: Model Validation. This step verifies whether the LLM output conforms to the model validation specification. If the model validation fails, the LLM will re-output the formatted content until it passes the model validation.

[0071] Step 5: After model validation, entity content can be extracted and saved according to standard format. In the example provided above, the extracted entities are "a certain airport" and "fuel pressure".

[0072] The process of entity parsing and relation edge extraction is as follows: Figure 4 As shown.

[0073] Using the same example as "At 3:10 AM, at 35.549393°N, 139.779839°E, the ground maintenance team at (an airport) reported unstable fuel pressure on two international flights during taxiing. The monitoring platform immediately marked the location of the high-risk hangar on the map and retrieved the weather conditions for the past 24 hours, indicating that temperature changes may have amplified the risk," we have already extracted the nodes "airport" and "fuel pressure" through node extraction operations. Now, we need to extract the event between the two nodes and connect the event edge to the two nodes.

[0074] Step 1: Data input. Data input includes extracted nodes, custom prompts, timestamps, edge types, data content, etc., which are important bases for edge extraction.

[0075] Step 2: Integrate the input data, which requires combining the extracted nodes, custom prompts, etc. The data structure is as follows:

[0076] context = {text content, (contend); timestamp, (timestamp); edge type, (edge.type); text type, (contend.type); extracted nodes, (extracted_nodes); custom template, (custom_prompt)}.

[0077] Step 3: Combine LLM with the prompt project output, and perform structured output according to the prompt project requirements. The structured output template is as follows:

[0078] { “edges”:[ { “relation_type”:“relation attribute”, “source_entity_id”:data type id, “target_entity_id”:target entity id, “fact”:“event”, “valid_at”:event occurrence time, “invalid_at”:database entry time} ]}.

[0079] Step 4: Time model extraction. Step 4 is executed asynchronously with Step 3. Step 4 involves recording and saving the event times of the input text to ensure that the events recorded by the knowledge base management module are time-sensitive.

[0080] Step 5: This step is node parsing. For a node to be connected to the extracted edges, the content of each node must be interpreted using LLM in order to connect the corresponding edges and ultimately form a graph database for storage.

[0081] Step 6: Analyze the connections between nodes and edges.

[0082] Only through the above four steps can the points and nodes be truly connected to form a graph, which is the complete process of spatiotemporal event extraction.

[0083] The above steps extract entities (nodes) and relations (edges) from the input unstructured data. The extracted entities and relations are "candidate knowledge," which need to be mapped to a predefined ontology before being stored in the graph database to generate a spatiotemporal knowledge graph. The contents stored in the graph database can be found in [link to relevant documentation]. Figure 5 ,For example:

[0084] The entity “a certain airport” is mapped to the dbo:Airport category in the ontology.

[0085] The entity “Unstable fuel pressure” is mapped to the category 'ex: AircraftSystemStatus' with the attribute status: “unstable”.

[0086] The relationship “reports” is mapped to the ex:reports relationship.

[0087] Through this formal mapping, unstructured text is transformed into a logically compliant knowledge graph fragment composed of typed nodes and edges, and stored in a graph database (such as Neo4j). The content stored in the graph database is not just simple points and lines, but knowledge units with rich semantic and type information, which is also a prerequisite for further verification.

[0088] Step 2: Introduce a reasoning mechanism based on formal rules to perform fact verification, relational reasoning, and contradiction testing on entities and relationships in the spatiotemporal knowledge graph, and generate a credible event reasoning chain.

[0089] Understandably, the credibility of each piece of information in the spatiotemporal knowledge graph generated in step 1 needs to be verified. This embodiment of the invention introduces a reasoning verification mechanism based on semantic network rules. Running after the spatiotemporal knowledge graph is constructed and before the narrative map is generated, it performs the following three key tasks.

[0090] (1) Fact verification:

[0091] The system utilizes a pre-built semantic network rule base (rules based on graph computation, with non-linear if-then judgments) to verify facts in the spatiotemporal knowledge graph. For example, a rule can be defined as: "The departure time (e.g., departureTime) of a flight must be earlier than its arrival time (e.g., arrivalTime)." If the LLM extracts a flight whose departure time is later than its arrival time, the inference engine will mark this relationship as a "logical contradiction" and exclude it from the trusted event chain.

[0092] The validation rules are formally represented as follows:

[0093] @prefix rdf:<http: / / www.w3.org / 1999 / 02 / 22-rdf-syntax-ns#> .

[0094] @prefix xsd:<http: / / www.w3.org / 2001 / XMLSchema#> .

[0095] @prefix ex:<http: / / example.org / flight#> .

[0096] #illustrate:

[0097] # 1) The rule depends on whether the departureTime or arrivalTime is of type xsd:dateTime or xsd:dateTimeStamp;

[0098] # 2) Using the built-in comparison function: lessThan / ge (>=), Jena can compare numeric values ​​with comparable types such as date and time;

[0099] #3) The rule is based on forward reasoning and will not delete triples; the following uses derivation tags to achieve "exclusion".

[0100] # A. Time Consistency: Takeoff < Landing => Marking Passed.

[0101] [FlightTimeOK:

[0102] (?f rdf:type ex:Flight)

[0103] (?f ex:departureTime ?dep)

[0104] (?f ex:arrivalTime ?arr)

[0105] lessThan(?dep,?arr) # ?dep < ?arr

[0106] ->

[0107] (?f ex:timeConstraintChecked true)

[0108] (?f ex:isLogicallyConsistent true)

[0109] ] .

[0110] # B. Timing contradiction: Takeoff >= Landing => Labeling logic contradiction.

[0111] [FlightTimeConflict:]

[0112] (?f rdf:type ex:Flight)

[0113] (?f ex:departureTime ?dep)

[0114] (?f ex:arrivalTime ?arr)

[0115] ge(?dep,?arr) # ?dep >= ?arr

[0116] ->

[0117] (?f ex:hasLogicalConflict ex:TimeOrderConflict)

[0118] (?f ex:excludedFromTrustedChain true)

[0119] ] .

[0120] # C. Trusted event chain derivation (only if no contradiction is found and constraint checks pass).

[0121] [TrustedChainInclude:]

[0122] (?f rdf:type ex:Flight)

[0123] (?f ex:departureTime ?dep)

[0124] (?f ex:arrivalTime ?arr)

[0125] lessThan(?dep, ?arr) # Satisfies timing requirements

[0126] noValue(?f ex: hasLogicalConflict ?c) # Not marked as a contradiction

[0127] ->

[0128] (?f ex:inTrustedEventChain true)

[0129] ] .

[0130] (2) Relational reasoning:

[0131] Based on existing facts, new, implicit relationships are inferred. Standard Semantic Web reasoning rules, such as GeoSPARQL, can be used here. For example:

[0132] Rule: If entity A is located within region C (geof: sfWithin), and entity B is also located within region C, then it can be inferred that entity A and entity B have a spatial proximity relationship (e.g., isSpatiallyCo-locatedWith).

[0133] Application: In a spatiotemporal knowledge graph, if "Event A occurred in City W" and "Event B occurred in City W", the inference engine will automatically add a new, verified edge: "Event A" for example: is Spatially Co-locatedWith "Event B". This provides a reliable basis for discovering event clusters.

[0134] (3) Conflict detection:

[0135] Discover and process conflicting information in the spatiotemporal knowledge graph. For example, if "Flight X has landed safely" is extracted from one data source and "Flight X has lost contact" is extracted from another data source, the inference engine will identify this as a state conflict, mark it, and exclude it from the trusted event chain.

[0136] By employing a verification mechanism for spatiotemporal knowledge graphs, the role of the Large Language Model (LLM) shifts from "decision-maker" to "proposer." The knowledge extracted must undergo "review" by formalized rules, and only "credible knowledge" that passes this review can proceed to the next stage. With the continuous addition of verification rules, the illusion of a heavy knowledge extraction task for the Large Language Model (LLM) can be fundamentally resolved.

[0137] After the above verification, a reliable event reasoning chain for the spatiotemporal knowledge graph is generated.

[0138] In this embodiment of the invention, the spatiotemporal knowledge graph generated is updated and corrected based on real-time data. Extracted credible events are incrementally added to the spatiotemporal knowledge graph, and the credible reasoning process is iterated. This enables the credible event reasoning chain to automatically evolve, correct, and enhance under the influence of new data, demonstrating the adaptability of the spatiotemporal knowledge graph.

[0139] The adaptive nature of this invention is mainly reflected in the following two aspects:

[0140] (1) Data adaptation:

[0141] The structured extraction module can continuously receive new external knowledge (such as new news reports, sensor data, and user dialogue content) in real time and automatically transform it into new nodes and edges in the knowledge graph. It can also revise existing nodes and edges based on real-time input data (the system will not physically delete edges and nodes, but will retain the entire update history for backtracking). This ensures the timeliness of the spatiotemporal knowledge graph.

[0142] (2) Knowledge Adaptation (Evolution):

[0143] When new knowledge is added to the graph, the credible reasoning process is triggered again. Newly added facts may, through rules, generate entirely new inference conclusions with existing facts, or modify or even overturn past conclusions. For example, if a new event, "a typhoon warning was issued in a certain region" (from a new session), is added, the reasoning mechanism can automatically link this event with the previous event, "unstable fuel pressure at a certain airport," to deduce a new causal hypothesis chain: "Typhoon warning" → e.g., mayCause → "Changes in weather conditions" → e.g., mayAmplifyRiskOf → "Unstable fuel pressure." This "self-evolutionary" ability of knowledge allows the system to continuously provide deeper and more comprehensive insights as information evolves.

[0144] Step 3: Extract key spatiotemporal information from the verified spatiotemporal knowledge graph in the form of multi-turn dialogue, fill the key spatiotemporal information into the story map configuration file, and generate the configuration template of the story map in a structured output manner.

[0145] Understandably, the goal of this step is to present the "credible event reasoning chain" generated and verified in step 2 to the user in an intuitive and interactive way. The map is no longer just a display board of geographical locations, but a canvas that carries and reveals complex reasoning processes.

[0146] The verified trusted event reasoning chain above provides the necessary structured data. This part demonstrates the automated story map configuration code generation method of the present invention. In an embodiment of the present invention, the step of extracting key spatiotemporal information from the verified spatiotemporal knowledge graph in a turn-based dialogue format, filling the key spatiotemporal information into the story map configuration file, and generating a story map configuration template in a structured output manner includes:

[0147] Step 31: Based on the user's dialogue question, locate the corresponding node from the spatiotemporal knowledge graph using the Large Language Model (LLM) and obtain all attributes of the node;

[0148] Step 32: Based on all the attributes of the node, traverse all the inbound and outbound relationships of the node in the spatiotemporal knowledge graph. For each relationship, collect the relationship type, relationship attributes, and the attributes and tags of the connected nodes, and organize all the collected information into a structured search result output.

[0149] Understandably, this invention is designed to continuously extract knowledge from the knowledge graph management module in the form of dialogue. Users can also modify their opinions during the dialogue and control the pace of the spatiotemporal narrative map. The knowledge graph management module will also output the knowledge in a structured form. Finally, these dialogues are collected, and important content for configuration files is extracted from them. See also Figure 6 The following demonstrates the operation of the retrieval module and the knowledge graph management module during the user's dialogue with the Large Language Model (LLM).

[0150] User question: What did the International Air Traffic Monitoring Platform detect at a certain airport on December 8, 2025?

[0151] At this point, the Large Language Model (LLM) and graph database management module will automatically locate the node "airport" based on the user's question. Then, based on the custom graph data search code, it will detect all edges and nodes connected to that node. The pseudocode for the retrieval method is shown below:

[0152] / / Pseudocode: Finding nodes and their relationship networks based on UUID

[0153] function findNodeAndRelationshipsByUUID(uuid):

[0154] / / Initialize the list of results

[0155] results = [ ]

[0156] / / Find the node with the specified UUID in the graph.

[0157] sourceNode = Find the node n in the graph whose attribute uuid is equal to the input uuid.

[0158] if sourceNode does not exist:

[0159] return empty result

[0160] / / Get the attributes of the source node

[0161] sourceProperties = All properties of sourceNode

[0162] / / Traverse all relationships of this node

[0163] For each relationship r connected to sourceNode:

[0164] / / Get relation type and attributes

[0165] relationshipType = type of r

[0166] relationshipProperties = All properties of r

[0167] / / Get connected node information

[0168] connectedNode = another node connected via relation r

[0169] targetProperties = All properties of connectedNode

[0170] targetLabels = All tags of connectedNode

[0171] / / Add the results to the list

[0172] results.append({

[0173] "source_properties": sourceProperties,

[0174] "relationship_type":relationshipType,

[0175] "rel_properties":relationshipProperties,

[0176] "target_properties": targetProperties,

[0177] "target_labels": targetLabels

[0178] })

[0179] return results

[0180] This pseudocode describes a graph database query process. It first locates a specific node in the graph based on a given UUID (Universally Unique Identifier), then obtains all the attributes of that node, then traverses all the inbound and outbound relationships of that node, and for each relationship, collects the relationship type, relationship attributes, and the attributes and labels of the connected nodes. Finally, it organizes all the collected information into a structured search result and returns it.

[0181] Therefore, the content answered by the Large Language Model (LLM) can be highly relevant to the user's question, which improves the quality of the retrieval.

[0182] LLM: At 2:00 AM on December 8, 2025, the International Air Traffic Monitoring Platform detected fluctuations in the engine temperature data of multiple cargo planes at an airport (51.470020 N, -0.454295 W), with some readings briefly exceeding the safety threshold.

[0183] The large model's responses include key information such as time, location, and event. These responses are collected and used as structured search results for subsequent automated document generation.

[0184] Step 33: Based on the intelligent agent's perception of user intent, when the user intent is perceived to be to generate a spatiotemporal narrative map configuration task, a state transition is triggered. The state transition refers to the transition from dialogue mode to spatiotemporal narrative map configuration mode.

[0185] Step 34: Map the structured search results to the story map configuration file to generate a story map configuration template.

[0186] Understandably, this invention designs a task awareness and automatic conversion module as an intelligent scheduling hub between the dialogue flow and the task pipeline. Its core function is to analyze the user's interactive intent generated in multi-turn dialogues with the Large Language Model (LLM) in real time. When the agent determines through intent recognition that the user's goal has changed from open-ended question-and-answer to the specific task of generating a spatiotemporal narrative map configuration, a state transition will be automatically triggered. At this time, the Large Language Model (LLM) will immediately exit the dialogue mode and start as a configuration generation engine, autonomously executing the complete workflow of extracting verified event chains from the spatiotemporal knowledge graph, organizing narrative logic, and generating a structured map configuration. In this mode, the user interaction model undergoes a fundamental transformation: the user does not need to intervene in the complex configuration process; their role is simplified to initiating tasks and confirming goals. The system takes over all intermediate links from intent recognition to configuration output, achieving end-to-end automation. This design, on the one hand, lowers the user threshold through the natural interaction of "dialogue as instruction," and on the other hand, ensures the efficiency and accuracy of task execution through the automatic scheduling of the agent. Ultimately, while ensuring that the user has the final decision-making power (controllability), it greatly improves the automation level of the entire narrative map construction process.

[0187] The interactive map configuration generation based on mapping rules combines an intelligent large-scale language model (LLM) with precise Prompt engineering to form a dynamic and intelligent automatic map configuration generation system. This system automatically extracts key spatiotemporal information through multi-turn interactive dialogue and then populates it into the story map's configuration file. Specifically, the LLM generates configuration templates including main titles, subtitles, chapter titles, chapter descriptions, and geographic location information through structured output.

[0188] This automated, structured extraction and filling method enables seamless integration of spatiotemporal narratives, intelligently configuring the core elements required for each chapter based on dynamic dialogue content, and providing a solid foundation for accurate mapping of interactive map configurations. This approach not only improves the processing efficiency of spatiotemporal data but also greatly enhances the flexibility and adaptability of map configuration, providing strong technical support for storytelling and visualization in complex scenes.

[0189] Step 4: Map the configuration information in the configuration template to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map.

[0190] Understandably, the configuration information in the configuration template generated in the above steps is mapped to the spatiotemporal narrative map configuration. The configuration template includes the main title, subtitle, chapter title, chapter description, and geographic location information.

[0191] In one embodiment of the present invention, mapping configuration information in the configuration template to a spatiotemporal narrative map configuration to generate a spatiotemporal narrative map includes:

[0192] Map the main title and subtitle to the header file configuration of the spatiotemporal narrative map, and generate the header file configuration file;

[0193] Map chapter titles, chapter descriptions, and geographic location information to chapter file configurations to generate chapter configuration files;

[0194] Based on the header configuration file and the chapter configuration file, the header file and chapter file of the spatiotemporal narrative map are generated.

[0195] The header file configuration is as follows:

[0196] config = { "style": 'map / style.json', "showMarkers": False, "markerColor": '#3FB1CE', "inset": True, "legend": False, "theme": 'dark', "useCustomLayers": True, "bookmarks": True, "chapterReturn": True, "title": data["main_title"], "logo":, "subtitle": data["sub_title"], "byline":, "mobileview":' <div id=""rotate-mobile”"> <em> For optimal viewing of this storytelling map on mobile, rotate your device to a horizontal orientation.< / em> <img src=""images / device.png”"> ', "footer": 'Source: sourcecitations, etc. Created using <a href=""https： / / github.com / digidem / maplibre-storymap”" target=""_blank”"> MapLibre Storytelling template.'}

[0197] The above shows the header file configuration. You only need to map the main title and subtitle in the configuration template to the header file.

[0198] The chapter configuration file is as follows:

[0199] new_json = { "id": unique_id, "alignment": 'left' if i % 2 == 1 else'right', "hidden": False, "title": chapter["title"], "image": False, "description": chapter["description"], "location": { "center": chapter["center"], "zoom": 10, "pitch": 0, "bearing": 0}, "mapAnimation": 'flyTo', "rotateAnimation": False, "mapInteractive": True, "onChapterEnter": [ { "layer": 'countries-fill', "opacity": [ "interpolate", ["linear"], ["zoom"], 3, 1, 6, 0.5, 10, 0 ]}, { "layer": 'airport-markers', "opacity": 1}, { "layer": 'airport-labels', "opacity": 1} ], "onChapterExit": [ { "layer": 'airport-markers', "opacity": 1}, { "layer": 'airport-labels', "opacity": 1} ]}.

[0200] Similarly, the extracted chapter titles, chapter descriptions, geographical locations, and other key information need to be mapped into these chapter configurations to complete the configuration of the story chapters. This is the entire process of generating the spatiotemporal narrative map configuration.

[0201] See Figure 7 A spatiotemporal narrative map generation system is provided in one embodiment of the present invention. The system includes:

[0202] The first generation module 701 is used to parse the input unstructured data based on the structured extraction module and the large language model, extract the entities and relationships in the unstructured data, output them in a structured form and verify them, and generate a spatiotemporal knowledge graph.

[0203] The verification module 702 is used to introduce a reasoning mechanism based on formal rules to perform fact verification, relation reasoning and contradiction testing on entities and relations in the spatiotemporal knowledge graph, and generate a credible event reasoning chain.

[0204] The second generation module 703 is used to extract key spatiotemporal information from the verified spatiotemporal knowledge graph in the form of multi-turn dialogue, fill the key spatiotemporal information into the story map configuration file, and generate the configuration template of the story map in a structured output manner.

[0205] The third generation module 704 is used to map the configuration information in the configuration template to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map.

[0206] It is understood that the spatiotemporal narrative map system provided by the present invention corresponds to the spatiotemporal narrative map method provided in the foregoing embodiments. The relevant technical features of the spatiotemporal narrative map system can be referred to the relevant technical features of the spatiotemporal narrative map method, and will not be repeated here.

[0207] Please see Figure 8 , Figure 8 This is a schematic diagram illustrating an embodiment of the electronic device provided in this invention. For example... Figure 8 As shown, an embodiment of the present invention provides an electronic device 800, including a memory 810, a processor 820, and a computer program 811 stored in the memory 810 and executable on the processor 820. When the processor 820 executes the computer program 811, it implements the steps of the above-described spatiotemporal narrative map generation method.

[0208] Please see Figure 9 , Figure 9 This is a schematic diagram illustrating an embodiment of a computer-readable storage medium provided by the present invention. (See diagram below.) Figure 9 As shown, this embodiment provides a computer-readable storage medium 900, on which a computer program 911 is stored. When the computer program 911 is executed by a processor, it implements the steps of the above-described spatiotemporal narrative map generation method.

[0209] The spatiotemporal narrative map generation method, system, and storage medium provided in this invention, compared with traditional static, predefined, or unreliable AI generation technologies, achieve significant breakthroughs in intelligence, adaptability, and reliable interaction efficiency, and have the following benefits:

[0210] (1) Deep reasoning and trust assurance.

[0211] Existing AI-generated methods are like unreliable "black boxes," and their conclusions cannot be fully trusted. This invention, through a dual mechanism of "LLM proposal + semantic network reasoning rule verification," can automatically construct a "credible event chain" that is logically rigorous, factually reliable, and has complete background information. This not only presents "what happened," but also clearly demonstrates "why it happened" and "what subsequent impacts it caused" through a traceable reasoning path, greatly improving the knowledge depth of the narrative and the overall credibility of decision-making applications.

[0212] (2) Dynamic evolution and in-depth insights.

[0213] Traditional methods, based on fixed data models, struggle to adapt to rapidly changing real-time event information. The knowledge graph constructed in this invention possesses real-time perception and self-evolution capabilities, automatically extracting new entities and relationships from multi-source data to form new knowledge, seamlessly integrating it into the existing knowledge system, and discovering previously unnoticed deep connections through the re-running of the inference engine, thus achieving knowledge value-added. This dynamism ensures that the story content remains synchronized, coherent, and continuously deepened with the latest developments. Combined with map visualization technology, the system can present complex spatiotemporal and causal relationships in an intuitive map application format, simplifying complexity and helping users quickly grasp the overall situation and key nodes, providing unprecedented and powerful support for efficient decision-making.

[0214] (3) Dialogue-based exploration and reasoning tracing.

[0215] Traditional tools often rely on cumbersome menu operations and parameter configurations for user interaction. This invention revolutionizes the interaction method with natural language dialogue. Users can use conversational commands for exploratory analysis (such as "show all airports related to this matter"), generating and adjusting story maps in real time. This "dialogue as analysis" model gives users unprecedented flexible control over the analysis process, making complex deconstruction processes transparent, and ultimately producing personalized and highly credible narrative results.

[0216] (4) Paradigm innovation and large-scale application.

[0217] Traditional interactive map creation heavily relies on GIS expert teams, resulting in long lead times and high costs. This invention, through automated and reliable reasoning and visual mapping, automates a significant amount of high-level intellectual labor, significantly reducing technical barriers and time costs. This enables non-technical users to quickly generate interactive analysis reports—previously requiring professional teams—in scenarios with high timeliness, complex information, and high credibility requirements, such as breaking news reporting, public emergency command, military exercise debriefing, and historical and cultural storytelling. This represents a paradigm shift from a "tool" to an "intelligent analysis partner," promoting the large-scale popularization and application of this technology.

[0218] It should be noted that the descriptions of each embodiment in the above embodiments have different focuses. For parts that are not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

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

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

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

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

[0223] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0224] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A method for generating spatiotemporal narrative maps, characterized in that, include: The structured extraction module integrates a large language model to parse the input unstructured data, extract entities and relationships from the unstructured data, output them in a structured form and verify them to generate a spatiotemporal knowledge graph. A reasoning mechanism based on formal rules is introduced to perform fact verification, relational reasoning, and contradiction testing on entities and relations in the spatiotemporal knowledge graph, generating a credible event reasoning chain; Key spatiotemporal information is extracted from the verified spatiotemporal knowledge graph through multi-turn dialogue, and the key spatiotemporal information is filled into the story map configuration file. The configuration template of the story map is generated in a structured output manner. Map the configuration information in the configuration template to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map; The introduction of a formal rule-based reasoning mechanism performs fact verification, relational reasoning, and contradiction checking on entities and relationships in the spatiotemporal knowledge graph to generate a credible event reasoning chain. This is followed by: The extracted credible events are incrementally added to the spatiotemporal knowledge graph, and the credible reasoning process is iterated to realize the automatic evolution, correction and enhancement of the credible event reasoning chain under the new data drive. The process involves extracting key spatiotemporal information from the validated spatiotemporal knowledge graph through multi-turn dialogue, populating the key spatiotemporal information into the story map configuration file, and generating a story map configuration template in a structured output manner, including: Based on the user's dialogue question, the corresponding node is located from the spatiotemporal knowledge graph using the Large Language Model (LLM) and all attributes of the node are obtained. Based on all the attributes of the node, all the inbound and outbound relationships of the node are traversed in the spatiotemporal knowledge graph. For each relationship, the relationship type, relationship attributes, and the attributes and tags of the connected nodes are collected. All the collected information is organized into a structured search result output. Based on the intelligent agent's perception of user intent, when the user intent is perceived to be to generate a spatiotemporal narrative map configuration task, a state transition is triggered. The state transition refers to the transition from dialogue mode to spatiotemporal narrative map configuration mode. The structured search results are mapped to the story map configuration file to generate a story map configuration template.

2. The generation method according to claim 1, characterized in that, The method involves using a structured extraction module to integrate a large language model to parse the input unstructured data, extracting entities and relationships from the unstructured data, outputting them in a structured form, validating the output, and generating a spatiotemporal knowledge graph, including: Based on the natural language understanding capabilities of the Large Language Model (LLM), the system performs preliminary parsing of the input unstructured data, integrating the text content, timestamps, and custom templates into a context object. Based on the context object, the context engineering designed according to the large language model outputs structured information containing entities and relationships identified from the context object, in accordance with the format requirements of the custom template. The system verifies whether the output structured information conforms to the predefined JSON data syntax rules. If it does not conform, it automatically requests the Large Language Model (LLM) to regenerate the structured information until it passes the verification. If it conforms, the system directly outputs the structured information. Entities and relationships are extracted from the structured information and mapped onto a predefined ontology to generate a spatiotemporal knowledge graph.

3. The generation method according to claim 2, characterized in that, The entity extraction process includes: Receive input unstructured data, determine the type of the unstructured data, the types of the unstructured data include plain text, message and JSON, and configure a unique identifier for the input unstructured data; The input unstructured data is integrated and processed to generate a context object based on data type, timestamp, and custom template. The data structure of the context object is as follows: context = {text content, (contend); timestamp, (timestamp); entity type, (entity.type); text type, (contend.type); custom template, (custom_prompt)}; Based on the Large Language Model (LLM), the context object is output in a structured manner according to a custom template. The structured output template is as follows: { "extracted_entities": [ {"name": "extracted entity content", "entity_type_id": entity id}, {"name": "extracted entity content", "entity_type_id": entity id} ]}; Verify whether the structured output of the large language model LLM conforms to the model validation specification. If it does not conform, request the large language model LLM to re-output until it passes the model validation. If it conforms, the process ends. After model validation, entity content is extracted and saved from the structured output according to the standard format.

4. The generation method according to claim 3, characterized in that, The relation extraction process includes: The system receives data input, which includes extracted nodes, a custom template, a timestamp, edge type, and data content. This data input is then integrated to form a context object. The data structure of the context object is as follows: context = {text content, (contend); timestamp, (timestamp); edge type, (edge.type); text type, (contend.type); extracted nodes, (extracted_nodes); Custom template, (custom_prompt)}; Based on the Large Language Model (LLM), the context object is output in a structured manner according to a custom template. The structured output template is as follows: { "edges": [ { "relation_type": "relation attribute", "source_entity_id": data type id, "target_entity_id": target entity id, "fact": "event", "valid_at": "event occurrence", "invalid_at": database entry time} ]}; Based on the time model, the event occurrence time is extracted from the data input, and edges with time are extracted; The extracted nodes are parsed based on the Large Language Model (LLM), and connections are made with the extracted edges, which are then saved to the graph database.

5. The generation method according to claim 1, characterized in that, The introduction of a formal rule-based reasoning mechanism performs fact verification, relational reasoning, and contradiction checking on entities and relationships in the spatiotemporal knowledge graph to generate a credible event reasoning chain, including: The facts in the spatiotemporal knowledge graph are verified using a pre-built semantic network rule base; Using semantic web reasoning rules, new implicit relationships between different entities can be inferred based on existing facts; The inference engine detects conflict information in the spatiotemporal knowledge graph. If a state conflict is detected, it is marked and removed from the trusted event inference chain.

6. The generation method according to claim 1, characterized in that, The configuration template includes a main title, subtitle, chapter title, chapter description, and geographic location information; Mapping the configuration information in the configuration template to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map includes: Map the main title and subtitle to the header file configuration of the spatiotemporal narrative map, and generate the header file configuration file; Map chapter titles, chapter descriptions, and geographic location information to chapter file configurations to generate chapter configuration files; Based on the header configuration file and the chapter configuration file, the header file and chapter file of the spatiotemporal narrative map are generated.

7. A spatiotemporal narrative map generation system, characterized in that, include: The first generation module is used to parse the input unstructured data based on the structured extraction module and the large language model, extract the entities and relationships in the unstructured data, output them in a structured form and verify them, and generate a spatiotemporal knowledge graph. The verification module is used to introduce a reasoning mechanism based on formal rules to perform fact verification, relation reasoning and contradiction testing on entities and relations in the spatiotemporal knowledge graph, and generate a credible event reasoning chain. The second generation module is used to extract key spatiotemporal information from the verified spatiotemporal knowledge graph in the form of multi-turn dialogue, fill the key spatiotemporal information into the story map configuration file, and generate the configuration template of the story map in a structured output manner. The third generation module is used to map the configuration information in the configuration template to the spatiotemporal narrative map configuration to generate the spatiotemporal narrative map. The introduction of a formal rule-based reasoning mechanism performs fact verification, relational reasoning, and contradiction checking on entities and relationships in the spatiotemporal knowledge graph to generate a credible event reasoning chain. This is followed by: The extracted credible events are incrementally added to the spatiotemporal knowledge graph, and the credible reasoning process is iterated to realize the automatic evolution, correction and enhancement of the credible event reasoning chain under the new data drive. The process involves extracting key spatiotemporal information from the validated spatiotemporal knowledge graph through multi-turn dialogue, populating the key spatiotemporal information into the story map configuration file, and generating a story map configuration template in a structured output manner, including: Based on the user's dialogue question, the corresponding node is located from the spatiotemporal knowledge graph using the Large Language Model (LLM) and all attributes of the node are obtained. Based on all the attributes of the node, all the inbound and outbound relationships of the node are traversed in the spatiotemporal knowledge graph. For each relationship, the relationship type, relationship attributes, and the attributes and tags of the connected nodes are collected. All the collected information is organized into a structured search result output. Based on the intelligent agent's perception of user intent, when the user intent is perceived to be to generate a spatiotemporal narrative map configuration task, a state transition is triggered. The state transition refers to the transition from dialogue mode to spatiotemporal narrative map configuration mode. The structured search results are mapped to the story map configuration file to generate a story map configuration template.

8. A computer-readable storage medium, characterized in that, It stores a computer program, which is executed by a processor according to the spatiotemporal narrative map generation method of any one of claims 1-6.

Images