Method and apparatus for determining scheduling costs for large-scale measurement tasks

Abstract

This invention provides a method and apparatus for determining scheduling costs for large-scale measurement tasks, relating to the field of robotics. The method includes: receiving a set of measurement tasks, which contains multiple scheduling tasks; based on the scheduling tasks, performing node type conversion and / or incremental node insertion on the current scheduling cost cache graph, and obtaining a target scheduling cost cache graph after satisfying connectivity conditions. Nodes in the target scheduling cost cache graph represent points in the configuration space, and are divided into key nodes associated with scheduling tasks and transition nodes connecting key nodes. The values ​​corresponding to the connecting edges between nodes represent scheduling costs; querying the scheduling costs represented by the connecting edges in the target scheduling cost cache graph to construct a scheduling cost matrix corresponding to the set of measurement tasks. This invention addresses the problem of low computational efficiency in solving the scheduling cost function in the robot scheduling decision space under large-scale task scheduling scenarios.

Description

Technical Field

[0001] This invention relates to the field of robotics, and in particular to a method and apparatus for determining scheduling costs for large-scale measurement tasks. Background Technology

[0002] In measurement scenarios, robots need to perform hundreds to thousands of spatially discrete shooting tasks. Each task corresponds to a feasible pose in the configuration space. Based on this, the configuration space scheduling cost between any two tasks needs to be calculated to support global optimal path planning and task scheduling.

[0003] Currently, the mainstream approach employs pairwise exact path planning: for each task pair, a configuration space path planner is invoked to search for feasible paths under obstacle constraints, and the integral cost of these paths is used as the scheduling cost for that task pair. While this method guarantees path feasibility and cost accuracy, it requires execution... The independent planning operation has problems such as high computational complexity and excessive time to construct a complete cost matrix, thus failing to meet the real-time scheduling requirements of industrial sites. Summary of the Invention

[0004] In view of this, the purpose of the present invention is to provide a method and apparatus for determining the scheduling cost for large-scale measurement tasks, and to solve the problem of low computational efficiency when solving the scheduling cost function in the robot scheduling decision space in large-scale task scheduling scenarios.

[0005] In a first aspect, the present invention provides a method for determining the scheduling cost for large-scale measurement tasks, comprising: Receive a set of measurement tasks, which contains multiple scheduled tasks; Based on the scheduling task, the node type conversion and / or incremental node insertion are performed on the current scheduling cost cache graph, and the target scheduling cost cache graph is obtained after the connectivity condition is met. The nodes in the target scheduling cost cache graph are used to represent the points in the configuration space. They are divided into key nodes associated with the scheduling task and transition nodes that connect the key nodes. The value of the connection edge between the nodes is used to represent the scheduling cost. The scheduling costs represented by the connecting edges in the target scheduling cost cache graph are queried and used to construct the scheduling cost matrix corresponding to the set of measurement tasks.

[0006] In one implementation, based on the scheduling task, performing node type conversion and / or incremental node insertion on the current scheduling cost cache graph includes: In the current scheduling cost cache graph, perform a nearest neighbor search on the scheduled task; If a transition node matching the scheduling task is determined through nearest neighbor search, a node type conversion is performed to convert the transition node into a key node corresponding to the scheduling task. If the nearest neighbor search determines that there is no transition node matching the scheduled task, perform incremental node insertion and insert the key node corresponding to the scheduled task into the current scheduling cost cache graph.

[0007] In one implementation, the target scheduling cost cache graph is obtained after the connectivity condition is met, including: Determine whether the connected components of the nodes in the current scheduling cost cache graph satisfy the connectivity condition, and if the result is negative, perform the following operation: If the total number of nodes in the current scheduling cost cache graph does not reach the upper limit, an insertion operation is performed on the current scheduling cost cache graph to insert a transition node into the current scheduling cost cache graph. An intermediate scheduling cost cache graph is obtained through neighbor node connection tests. Then, connectivity condition judgment is performed until the connectivity domain of any node in the intermediate scheduling cost cache graph satisfies the connectivity condition, and the target scheduling cost cache graph is obtained. Alternatively, if the total number of nodes in the current scheduling cost cache graph reaches the upper limit, then a connection operation is performed between the connected domains of the nodes in the current scheduling cost cache graph to obtain the target scheduling cost cache graph.

[0008] In one implementation, it is determined whether the connectivity domains of nodes in the current scheduling cost cache graph satisfy the connectivity condition: Determine the number of first critical nodes contained in the current scheduling cost cache graph, and the number of second critical nodes contained in the node connectivity domains of the current scheduling cost cache graph; The connectivity index is determined based on the number of the first key nodes and the largest number of the second key nodes. If the connectivity index is greater than the preset index threshold, the connectivity condition is determined to be met.

[0009] In one implementation, an insertion operation is performed on the current scheduling cost cache graph to insert the transition node into the current scheduling cost cache graph, and an intermediate current scheduling cost cache graph is obtained through neighbor node connection testing, including: Determine the primary node's connectivity from the node connectivity components contained in the current scheduling cost cache graph; For any target node connected component in the current scheduling cost cache graph, excluding the master node connected component, perform sampling; If the target node's connected component and the master node's connected component satisfy the preset narrow channel condition, then perform the following operation: Based on the configuration space distance between any key node in the target node's connected domain and any key node in the master node's connected domain, multiple node pairs are determined; A specified path planner is used to perform path planning between each pair of nodes, and the specified path planner is different from the path planner used when the narrow passage condition is not met; Based on the execution status of path planning, and / or the total number of nodes contained in the current scheduling cost cache graph after path planning, an intermediate scheduling cost cache graph is obtained.

[0010] In one implementation, based on the execution status of path planning and / or the total number of nodes in the current scheduling cost cache graph after path planning, an intermediate scheduling cost cache graph is obtained through neighbor node connection testing, including: If the path planning is successful and the total number of nodes has not reached the upper limit, then according to the result of the path planning, a transition node is inserted into the current scheduling cost cache graph. The inserted transition node and the key node contained in the node pair are connected and the value of the connection edge is updated. The intermediate scheduling cost cache graph is obtained through neighbor node connection test. If the path planning is successful and the total number of nodes reaches the upper limit, then connect the key nodes contained in the node pair and update the value of the connection edge to obtain the intermediate scheduling cost cache graph. If path planning fails for each node, it is determined that the target node's connected domain and the master node's connected domain are not connected.

[0011] In one implementation, the scheduling cost represented by the connecting edges in the target scheduling cost cache graph is queried to construct the scheduling cost matrix corresponding to the set of measurement tasks, including: For any two scheduled tasks, query the cost status between the two scheduled tasks; If the cost state is known, read the scheduling cost between the two scheduled tasks; When the cost state is unknown, the target scheduling cost cache graph is mapped twice based on the association between the scheduling task and the key node; Based on the result of the two mappings, a shortest path search is performed on the two scheduling tasks in the target scheduling cost cache graph to obtain the scheduling cost between the two scheduling tasks, and the cost state is set to a known state. Based on the scheduling cost between two scheduling tasks, construct the scheduling cost matrix corresponding to the measurement task set.

[0012] In one implementation, the method further includes: After constructing the scheduling cost matrix corresponding to the set of measurement tasks, all nodes in the target scheduling cost cache graph are reset to transition nodes to obtain a new current scheduling cost cache graph, so that the new scheduling cost cache graph can be reused when a new set of measurement tasks is received.

[0013] In one implementation, the method further includes: Determine whether the number of nodes in the current scheduling cost cache graph has reached the preset upper limit; If so, then based on one or more of the node connectivity, node density, and node historical attributes in the current scheduling cost cache graph, the transition nodes contained in the current scheduling cost cache graph are pruned to obtain a new current scheduling cost cache graph.

[0014] Secondly, the present invention also provides a scheduling cost determination apparatus for large-scale measurement tasks, comprising: The task receiving module is used to receive a set of measurement tasks, which contains multiple scheduled tasks. The cache graph update module is used to perform node type conversion and / or incremental node insertion on the current scheduling cost cache graph based on the scheduling task, and obtain the target scheduling cost cache graph after the connectivity condition is met. The nodes in the target scheduling cost cache graph are used to represent the points in the configuration space. They are divided into key nodes associated with scheduling tasks and transition nodes that connect key nodes. The value of the connection edge between nodes is used to represent the scheduling cost. The cost query module is used to query the scheduling costs represented by the connecting edges in the target scheduling cost cache graph, in order to construct the scheduling cost matrix corresponding to the set of measurement tasks.

[0015] Thirdly, the present invention also provides an electronic device including a processor and a memory, the memory storing computer-executable instructions executable by the processor, the processor executing the computer-executable instructions to implement any of the methods provided in the first aspect.

[0016] This invention provides a method and apparatus for determining scheduling costs for large-scale measurement tasks. It obtains a target scheduling cost cache graph by performing node type conversion and / or incremental node insertion on the scheduling cost cache graph, and after satisfying connectivity conditions. This allows the scheduling cost cache graph to dynamically evolve with the set of measurement tasks. Nodes in the target scheduling cost cache graph represent points in the configuration space, categorized as key nodes and transition nodes. The values ​​of connecting edges directly represent the scheduling cost. Therefore, the scheduling cost matrix can be constructed directly by querying the values ​​of connecting edges in the target scheduling cost cache graph. This avoids repeated traversal and calculation of the entire robot scheduling decision space in large-scale task scheduling scenarios. Furthermore, as the scheduling cost cache graph dynamically evolves, only the local graph structure related to incremental node insertion needs to be maintained, or even the scheduling cost cache graph itself is no longer required, significantly reducing computational load and improving the efficiency of constructing the scheduling cost function.

[0017] Other features and advantages of the invention will be set forth in the following description, and will be apparent in part from the description, or may be learned by practicing the invention. The objects and other advantages of the invention are realized and obtained through the structures particularly pointed out in the description and the drawings.

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

[0019] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0020] Figure 1 A flowchart illustrating a method for determining scheduling costs for large-scale measurement tasks, provided in an embodiment of the present invention; Figure 2 A schematic diagram of a scheduling cost cache graph provided in an embodiment of the present invention; Figure 3 A schematic diagram illustrating the construction process of a scheduling cost cache graph provided in an embodiment of the present invention; Figure 4 A flowchart for fast querying scheduling costs is provided in this embodiment of the invention; Figure 5 A schematic diagram of a scheduling cost determination device for large-scale measurement tasks provided in an embodiment of the present invention; Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below in conjunction with the embodiments. 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.

[0022] Currently, existing methods for determining scheduling costs suffer from high computational complexity and excessive time consumption in constructing a complete cost matrix.

[0023] To reduce the computational cost of scheduling, related techniques propose using approximate scheduling costs instead of precise costs. ; Among them, subscript Indicates from the task To the mission , Indicates precise cost, Represents an approximate cost. Indicates a fixed cost. Represents the linear cost in joint space. Represents the linear cost in Cartesian space. , These are the corresponding weights.

[0024] While this approximate scheduling cost algorithm boasts high computational efficiency and meets real-time requirements, its accuracy is insufficient. The core issue lies in the inability to explicitly determine the weights: there is a lack of stable proportional relationships between the cost components, and the weights dynamically drift with changes in scene and spatial location, making unified calibration difficult. Another root cause of the cost inaccuracy is that neither the Cartesian space linear cost nor the joint space linear cost models the geometric constraints of the real feasible space; when the linear interpolation path traverses obstacles or infeasible regions, the cost deviates significantly from the actual movement cost. Furthermore, this comprehensive cost lacks physical interpretability: the three types of costs have different dimensions, and the weighted fusion value has no clear physical meaning (such as time, distance, or energy), making it impossible for downstream modules (such as time window constraint solvers) to directly analyze and reuse, significantly limiting its system-level integration capabilities.

[0025] Based on this, the present invention provides a method and apparatus for determining the scheduling cost for large-scale measurement tasks, which solves the problem of low computational efficiency when solving the scheduling cost function in the robot scheduling decision space in large-scale task scheduling scenarios.

[0026] To facilitate understanding of this embodiment, a method for determining scheduling costs for large-scale measurement tasks, as disclosed in this embodiment of the invention, will first be described in detail. (See [link to relevant documentation]). Figure 1 The diagram shows a flowchart of a method for determining the scheduling cost of a large-scale measurement task. The method mainly includes the following steps S102 to S106: Step S102: Receive the set of measurement tasks.

[0027] The measurement task set refers to a set of scheduled tasks (also known as measurement tasks to be performed by the robot) generated by the system or customized by humans in a measurement operation scenario (such as a photogrammetry operation scenario).

[0028] Step S104: Based on the scheduling task, perform node type conversion and / or incremental node insertion on the current scheduling cost cache graph, and obtain the target scheduling cost cache graph after the connectivity condition is met.

[0029] The scheduling cost cache graph is built based on the robot configuration space and stored in a graph data structure. The nodes in the scheduling cost cache graph represent points in the configuration space, and the connecting edges in the scheduling cost cache graph represent the costs between the configurations in the configuration space corresponding to the connected nodes.

[0030] The current scheduling cost cache graph is the scheduling cost cache graph that is reused or initialized during this scheduling cost calculation. When performing the scheduling cost calculation for the first time, the current scheduling cost cache graph is empty. When performing scheduling cost calculations other than the first time, the current scheduling cost cache graph contains multiple transition nodes. These transition nodes are cached from transition nodes inserted into the cache graph during previous scheduling cost calculations, and / or are transformed from key nodes inserted into the cache graph during previous scheduling cost calculations.

[0031] The target scheduling cost cache graph is the scheduling cost cache graph obtained after node type conversion and / or incremental node insertion during this scheduling cost calculation process, and after passing the connectivity test. The nodes in the target scheduling cost cache graph are at least divided into key nodes associated with scheduling tasks and transitional nodes that connect key nodes. The values ​​corresponding to the connecting edges between nodes are used to characterize the scheduling cost.

[0032] In one implementation, the set of measurement tasks in the current round is traversed. For each scheduling task, a nearest neighbor search is used to find whether there are geometrically overlapping transition nodes in the current scheduling cost cache graph. If so, the node type is converted to a critical node; otherwise, a new critical node is created and inserted into the current scheduling cost cache graph. A TaskMap is established, and connectivity is checked. If the connectivity check fails, if the total number of nodes is less than the upper limit, a transition node is inserted. If the total number of nodes is greater than the upper limit, the connectivity domains of each node are connected by directly calculating the scheduling cost, thereby obtaining the target scheduling cost cache graph.

[0033] Step S106: Query the scheduling costs represented by the connecting edges in the target scheduling cost cache graph to construct the scheduling cost matrix corresponding to the measurement task set.

[0034] The scheduling cost matrix is ​​a two-dimensional array with row and column indices for the scheduled tasks, and its elements are... Storage tasks To the mission The minimum feasible movement cost is initially set to "unknown" and is dynamically populated and lazily updated by querying the target cache graph.

[0035] In one implementation, for each pair of scheduling tasks in the measurement task set... First, the cost status is queried. If it is in a known state, it can be read directly. If it is in an unknown state, a shortest path search is performed in the target scheduling cost cache graph to calculate the scheduling task. Find the minimum path cost; fill this cost into the scheduling cost matrix. The location is determined and marked as "known state"; once all task pairs have been traversed, the scheduling cost matrix is ​​constructed.

[0036] Furthermore, after the scheduling cost matrix is ​​constructed, all key nodes in the target scheduling cost cache graph can be converted into transition nodes as a new current scheduling cost cache graph for reuse when the measurement task set is received next time.

[0037] The scheduling cost determination method for large-scale measurement tasks provided in this invention performs node type conversion and / or incremental node insertion on the scheduling cost cache graph, and obtains the target scheduling cost cache graph after passing connectivity checks. This allows the scheduling cost cache graph to dynamically evolve with the set of measurement tasks. Nodes in the target scheduling cost cache graph represent points in the configuration space, and are divided into key nodes and transition nodes. The values ​​of connecting edges directly represent the scheduling cost. Therefore, the scheduling cost matrix can be constructed directly by querying the values ​​of connecting edges in the target scheduling cost cache graph. Thus, in large-scale task scheduling scenarios, repeated traversal and calculation of the entire robot scheduling decision space are avoided. Furthermore, as the scheduling cost cache graph dynamically evolves, only the local graph structure related to incremental node insertion in the scheduling cost cache graph needs to be maintained, or even the scheduling cost cache graph itself does not need to be maintained, thereby significantly reducing the computational load and improving the efficiency of constructing the scheduling cost function.

[0038] For ease of understanding, this embodiment of the invention provides a specific implementation of a scheduling cost determination method for large-scale measurement tasks.

[0039] First, the scheduling cost cache graph provided in the embodiments of the present invention will be explained. See [link to documentation]. Figure 2 The diagram shown is a schematic of a scheduling cost cache graph.

[0040] The nodes in the scheduling cost cache graph are divided into two categories: critical nodes and transitional nodes.

[0041] Key nodes: Each node corresponds one-to-one with a scheduled task, and each scheduled task is mapped through a mapping function. Quickly locate the unique key node; this function can be implemented using a hash table or an indexed array, with a lookup complexity of O(n log n). .

[0042] Transitional nodes: Any point within the feasible configuration space, with no direct task semantics, used only to improve connectivity between key nodes.

[0043] In this embodiment of the invention, by inserting transition nodes, isolated key nodes are interconnected, thereby forming a connected domain, such as... Figure 2 The connected components 1 and 2 are shown.

[0044] The node types of critical nodes and transition nodes can be transformed: after the scheduling cost matrix is ​​constructed, critical nodes can be downgraded to transition nodes; when a new set of measurement tasks is received, transition nodes that overlap with the new set of scheduling tasks can be upgraded to critical nodes.

[0045] Based on the aforementioned scheduling cost cache graph, this embodiment of the invention provides a specific implementation method for determining scheduling costs for large-scale measurement tasks, mainly involving the construction of the scheduling cost cache graph, fast querying of scheduling costs, and reuse and simplification of the scheduling cost cache graph.

[0046] (a) Construction of the scheduling cost cache graph: When constructing the scheduling cost cache graph, there are no strict timing constraints on the insertion of critical nodes and transition nodes, supporting arbitrary order, batch, or mixed insertion: all critical nodes can be injected in batches first, followed by the addition of transition nodes; transition nodes can be dynamically inserted during the critical node insertion process; or transition nodes can be incrementally inserted as needed after connectivity checks fail. This flexibility ensures the adaptive capability of the construction process to task distribution characteristics and real-time resource constraints.

[0047] Specifically, the process includes the following steps: Step 1: Based on the matching relationship between the scheduled task and the cached transition nodes in the current scheduling cost cache graph, perform node type conversion and / or incremental node insertion on the current scheduling cost cache graph to ensure that the current scheduling cost cache graph contains key nodes associated with the scheduled task. Specifically: Step 1.1: Perform a nearest neighbor search on the scheduled task in the current scheduling cost cache graph.

[0048] In one implementation, for any scheduling task, the corresponding feasible robot configuration is calculated using its pose information to obtain a target configuration point; then, in the node set of the current scheduling cost cache graph, a nearest neighbor search (such as KD-Tree) is performed. If there is a transition node whose distance is less than or equal to a preset matching threshold, it is determined to be "matched"; otherwise, it is determined to be "not matched".

[0049] Step 1.2: If a transition node matching the scheduling task is determined through nearest neighbor search, perform node type conversion to convert the transition node into a key node corresponding to the scheduling task.

[0050] In one implementation, if a matching transition node exists, its node type attribute is directly changed from "transition node" to "critical node", and the scheduling task and the node are mapped simultaneously through the TaskMap function (i.e., "Task→Node" entry is written into the hash table or index array).

[0051] Step 1.3: If the nearest neighbor search determines that there is no transition node matching the scheduling task, perform incremental node insertion and insert the key node corresponding to the scheduling task into the current scheduling cost cache graph.

[0052] In one implementation, if the scheduling cost cache graph is empty, or if the scheduling cost cache graph is non-empty and there are no matching transition nodes, a new key node is created: the node data is initialized with its corresponding target configuration point as coordinates and appended to the current scheduling cost cache graph; at the same time, the mapping relationship between the scheduling task and the node is registered in the TaskMap; the node initially has no connecting edges, and subsequently attempts to establish edge connections with neighboring nodes.

[0053] Step 2: Determine whether the node connectivity in the current scheduling cost cache graph satisfies the connectivity condition; if yes, obtain the target scheduling cost cache graph; if no, execute step 3 or step 4 based on the comparison between the current total number of nodes and the upper limit of the number.

[0054] This invention provides a specific process for determining whether connectivity conditions are met: Step 2.1: Determine the number of first key nodes contained in the current scheduling cost cache graph, and the number of second key nodes contained in the node connectivity domains of the current scheduling cost cache graph.

[0055] In one implementation, the total number of key nodes contained in the current scheduling cost cache graph is denoted as the first key node count. Starting from all key nodes, a graph traversal is performed on the entire current scheduling cost cache graph (including key nodes, transition nodes, and all established edges), but only key nodes are recorded and categorized as "visited targets". Each time, starting from an unvisited key node, all other key nodes reachable along any edge in the current scheduling cost cache graph (which can be reached via transition nodes) together form a connected component. After the traversal is completed, several disjoint sets of key nodes are obtained, each set being a connected component, and the number of key nodes contained in each set is counted and denoted as the second key node count.

[0056] Step 2.2: Determine the connectivity index based on the number of the first key nodes and the largest number of the second key nodes, and determine whether the connectivity condition is met if the connectivity index is greater than the preset index threshold.

[0057] In one implementation, the ratio between the largest number of second key nodes and the largest number of first key nodes can be used as a connectivity indicator. Specifically, let the number of key nodes in the connected component with the largest number of key nodes (i.e., the largest number of second key nodes) be denoted as [missing information]. The current scheduling cost cache graph contains the following number of first critical nodes: The connectivity index The calculation process is as follows: .like , If the preset threshold is used, then the connectivity condition is satisfied; if If the connectivity condition is not met, then the connectivity condition is not satisfied. For an example, please continue to see... Figure 2 , Figure 2 The current scheduling cost cache graph shown has 5 first critical nodes and 3 largest second critical nodes (i.e., the number of critical nodes contained in connected component 1). Therefore, the connectivity index... The value is 0.6, assuming When set to 0.5, the connectivity condition is determined to be met.

[0058] Step 3: If the total number of nodes in the current scheduling cost cache graph does not reach the upper limit, an insertion operation is performed on the current scheduling cost cache graph to insert the transition node that connects the key nodes into the current scheduling cost cache graph. An intermediate scheduling cost cache graph is obtained through neighbor node connection test. Then, connectivity condition judgment is performed until the connectivity domain of any node in the intermediate scheduling cost cache graph meets the connectivity condition, and the target scheduling cost cache graph is obtained.

[0059] In one implementation, if the connectivity condition is not met and the total number of nodes in the current scheduling cost cache graph has not reached the upper limit, then a method of inserting transition nodes needs to be used to increase connectivity. This can be achieved through methods such as edge sampling of connected components, random reflection sampling using PRM balls, or the planner planning transition nodes between connected components. Specifically, the following operations are performed: Identify all critical node connected components in the current scheduling cost cache graph, and select the two smallest connected components (or any two unconnected sets of critical nodes). For these two connected components, sample their boundary regions (i.e., feasible configuration regions in the neighborhood of each critical node within the connected component, close to the configuration space boundary, or near obstacles) to generate candidate transition nodes; or use the PRM sphere random reflection sampling strategy to generate test points at the obstacle boundary by mirror reflection. Then, for each candidate point, call the linear planner to attempt to plan a feasible path from the point to a representative critical node in each of the two connected components (e.g., the one closest to the centroid). If any candidate point can successfully establish a collision-free path with nodes in both connected components, insert the candidate point as a new transition node in the graph, and establish a bidirectional edge between it and the connected critical node (and possible neighboring transition nodes), with the edge weight set to the actual cost returned by the corresponding path planning. After insertion, immediately re-execute the connectivity check; if it still fails, repeat the above process. Each time, prioritize selecting the most isolated critical node or the smallest connected component combination, iteratively insert transition nodes to output the target scheduling cost cache graph. The entire process strictly controls the total number of nodes to not exceed the preset upper limit. If the upper limit has been reached and the connectivity conditions are still not met, the insertion of transition nodes will be terminated.

[0060] In another implementation, considering that sampling-based connectivity methods are inefficient when facing "narrow passages," a more efficient planner can be used to directly plan transition nodes between connected domains and insert or directly connect them, updating their weights. Here, a "narrow passage" refers to a set of feasible paths connecting two key nodes in the robot's configuration space, whose local measures (such as volume, width, or connectivity probability) are significantly lower than those of the surrounding feasible regions. The steps are as follows: Step 3.1: Determine the primary node connectivity from the node connectivity components contained in the current scheduling cost cache graph. Optionally, the node connectivity component corresponding to the largest number of second-critical nodes in the current scheduling cost cache graph can be used as the primary node connectivity component, or the required primary node connectivity component can be configured based on actual needs.

[0061] Step 3.2: For any target node connected component in the current scheduling cost cache graph other than the master node connected component, perform sampling. If the target node connected component and the master node connected component satisfy the preset narrow channel condition, then perform the following operation: (1) Based on the configuration space distance between any key node in the target node's connected domain and any key node in the master node's connected domain, determine multiple node pairs; (2) Use a specified path planner to perform path planning between each node pair. The specified path planner is different from the path planner used when the narrow channel condition is not met. For example, a linear planner can be used in the normal state (i.e., non-narrow channel), while other planners, such as sampling planners and optimization planners, can be used when the narrow channel condition is met; (3) Based on the execution status of the path planning and / or the total number of nodes contained in the current scheduling cost cache graph after path planning, obtain the intermediate scheduling cost cache graph through neighbor node connection tests.

[0062] In one implementation, based on the configuration space Euclidean distance between any key node in the target node's connected domain and any key node in the master node's connected domain, the distance values ​​of all possible key node pairs are calculated; the k node pairs with the smallest distances are selected and sorted in ascending order of distance; for each node pair, other planners (such as sampling planners, optimization planners, etc.) are used to directly plan the point-to-point path; based on the execution status of the path (i.e., success or failure) and the total number of nodes contained in the current scheduling cost cache graph, the specific cases are divided into the following three cases: Scenario 1: If path planning is successful and the total number of nodes has not reached the upper limit, then based on the path planning result, transition nodes are inserted into the current scheduling cost cache graph. The inserted transition nodes and the key nodes contained in the node pairs are connected, and the values ​​corresponding to the connecting edges are updated to obtain an intermediate scheduling cost cache graph. For example, if planning is successful and the total number of nodes in the current scheduling cost cache graph has not reached the preset upper limit, then the planned path is uniformly discretized into m intermediate configuration points in the configuration space, which are inserted as transition nodes into the current scheduling cost cache graph. Adjacent transition nodes and endpoint key nodes are connected sequentially according to the path order, and the edge weights corresponding to the connecting edges are calculated. It should be noted that any mature method can be used to calculate the edge weights, such as using configuration space distance, time cost, energy consumption, or motion smoothness, etc. This embodiment of the invention does not impose any limitations on this.

[0063] Scenario 2: If path planning is successful and the total number of nodes reaches the upper limit, then the key nodes in the node pair are connected and the values ​​of the connecting edges are updated to obtain an intermediate scheduling cost cache graph. For example, if planning is successful but the total number of nodes has reached the preset upper limit, an undirected edge is directly established between the two key nodes in the node pair, and the edge weights corresponding to the connecting edges are calculated.

[0064] Scenario 3: If path planning fails for each node, then the target node's connected domain is determined to be disconnected from the master node's connected domain.

[0065] Step 4: If the total number of nodes in the current scheduling cost cache graph reaches the upper limit, perform a connection operation between the connected domains of the nodes in the current scheduling cost cache graph to obtain the target scheduling cost cache graph.

[0066] In one implementation, when the total number of nodes in the current scheduling cost cache graph reaches the upper limit and it is still impossible to connect the nodes to each other, the scheduling cost of key nodes belonging to different nodes to each other is directly calculated, and this cost is used as the weight of the connecting edge to establish an undirected edge.

[0067] Based on the foregoing embodiments, this invention provides an application example for constructing a scheduling cost cache graph: For example, consider inserting the key node first and then the transition node. See [link to relevant documentation]. Figure 3 The diagram illustrates the construction process of a scheduling cost cache graph, which includes: first, inserting key nodes into the current scheduling cost cache graph; establishing a mapping relationship (TaskMap) between scheduling tasks and key nodes; performing connectivity checks on neighboring nodes; if the connectivity check fails, inserting transitional nodes into the current scheduling cost cache graph if the total number of nodes does not exceed the limit, connecting connected components if the total number of nodes exceeds the limit, and then performing connectivity checks again; if the connectivity check passes, the target scheduling cost cache graph is obtained.

[0068] For example, taking the insertion of transition nodes followed by key nodes as an example, the current scheduling cost cache graph with inserted transition nodes is obtained. It is then determined whether there is a transition node in the current scheduling cost cache graph that geometrically overlaps with the scheduling task. If so, the transition node is converted into a key node. If not, the key node corresponding to the scheduling task is inserted into the current scheduling cost cache graph, and a mapping relationship (TaskMap) is established between the scheduling task and the key node. Neighbor node connectivity is checked. If the connectivity check fails, a transition node is inserted into the current scheduling cost cache graph if the total number of nodes does not exceed the limit. If the total number of nodes exceeds the limit, the connected components are connected, and the connectivity check is performed again. If the connectivity check passes, the target scheduling cost cache graph is obtained.

[0069] (ii) Quick query of scheduling costs: In one implementation, see Figure 4 The flowchart shown is a fast query process for scheduling costs. First, a scheduling cost matrix is ​​constructed. When a query task is received, the cost status of the scheduling cost to be queried by the query task is determined. If it is in a known state, the scheduling cost is returned directly. If it is in an unknown state, the shortest path search is performed based on the target scheduling cost cache graph to obtain the scheduling cost, and the status of the scheduling cost is set to a known state.

[0070] The specific implementation process is as follows: (1) For any two scheduled tasks, query the cost status between the two scheduled tasks.

[0071] In one implementation, for any two scheduled tasks, the cost state between the two scheduled tasks is queried: in the scheduling cost matrix, tasks are... For row index, task Locate elements using column indexes Check its stored value: If the value is equal to the preset "unknown" flag (e.g., element value less than 0), If the element value is set to "unknown state" (or the dedicated boolean flag "is_computed=false"), it is considered a "known state"; otherwise (e.g., if the element value is greater than 0), it is considered a "known state". This query is a pure memory access operation with a time complexity of [missing information]. .

[0072] (2) When the cost state is known, read the scheduling cost between the two scheduling tasks.

[0073] In one implementation, when the cost state is known, the scheduling cost between the two scheduled tasks is read, and the process returns directly. The value already stored in the database is the minimum feasible motion cost that has been obtained and cached through the shortest path search and verified by the target scheduling cost cache graph.

[0074] (3) When the cost state is unknown, the target scheduling cost cache graph is mapped twice based on the association between the scheduling task and the key node. Based on the result of the two mappings, the shortest path search is performed on the two scheduling tasks in the target scheduling cost cache graph to obtain the scheduling cost between the two scheduling tasks, and the cost state is set to the known state.

[0075] In one implementation, the TaskMap function is first used to quickly perform a two-stage mapping of the scheduled tasks and key nodes in the scheduling cost cache graph, thus mapping the tasks... and Each is mapped to a corresponding key node in the target scheduling cost cache graph. and On the target call cost cache graph, with For the source point, First, check the connectivity between the source and destination. If they are not connected, there is no feasible path, and the cost can be set to a predetermined large value; if they are connected, run the shortest path algorithm (such as A* or Dijkstra's algorithm, with edge weights being the pre-stored feasible movement costs); then obtain the total weight of the shortest path. Then calculate the cost (large value or...) Write And update its status to "known".

[0076] It should be noted that the fast query of scheduling cost does not perform any collision detection or nearest neighbor calculation, and further reduces the total number of queries through lazy update.

[0077] (4) Based on the scheduling cost between the two scheduling tasks, construct the scheduling cost matrix corresponding to the measurement task set.

[0078] In one implementation, all scheduled tasks in the measurement task set are paired up, and for each pair of scheduled tasks, the cost query and filling are completed according to the aforementioned steps, thus completing the construction of the scheduling cost matrix.

[0079] In this embodiment of the invention, the fast query of scheduling cost does not perform any collision detection and nearest neighbor calculation, and the total number of queries is further reduced through lazy update.

[0080] (iii) Reuse of scheduling cost cache graph: After constructing the scheduling cost matrix corresponding to the set of measurement tasks, all nodes in the target scheduling cost cache graph are reset to transition nodes to obtain a new current scheduling cost cache graph, so that the new scheduling cost cache graph can be reused when a new set of measurement tasks is received.

[0081] In one implementation, all nodes in the target scheduling cost cache graph are traversed. Based on the type field in the node structure, such as "node.type==KEY_NODE", all nodes marked as "key nodes" are identified. For each key node, its type field is uniformly modified to "transition node" (e.g., "node.type=TRANSITION_NODE"), while retaining its configuration coordinates, adjacency relationships, and all connected edges and their weights unchanged. The TaskMap mapping table is cleared or reset: all "Task→Node" mapping entries are removed, making the mapping relationship invalid. The new current scheduling cost cache graph is marked as "pending reuse". At this time, the graph only contains transition nodes transformed from the original key nodes and the original transition nodes.

[0082] Based on this, when a new set of measurement tasks is received, the new scheduling cost cache graph is reused, specifically including: inserting a key node: if its corresponding configuration overlaps with the configuration of an existing transition node in the graph, the transition node is directly converted into a key node; subsequently, the scheduling cost cache construction method provided in the aforementioned embodiment continues to be executed until the connectivity requirements are met.

[0083] In this embodiment of the invention, the reuse mechanism of the scheduling cost cache is reflected in the following: when the measurement operation scenario remains unchanged (such as the configuration space constraints such as workpiece pose, camera layout, and distribution of environmental obstacles are unchanged), the cache graph constructed in the past can be directly reused as the initial state. Only through node type conversion and key node mapping, the new task set can be quickly adapted, which significantly avoids the overhead of repeated sampling, neighborhood connection and connectivity reconstruction required to start from an empty graph.

[0084] As the number of reuses increases, the proportion of "high-frequency configuration points" that have been marked as key nodes multiple times in the graph continues to rise. These points are often located in high-value areas in the robot's workspace where tasks are dense, paths intersect, or movements are frequent. Their surrounding connection relationships tend to stabilize after multiple rounds of verification, and the path cost data is more statistically representative and physically consistent, thereby gradually improving the accuracy of the entire cache graph in representing the real scheduling cost.

[0085] Optionally, the reuse of the scheduling cost cache graph is not limited to runtime node type conversion and incremental construction, but also supports persistent reuse across sessions and deployment cycles: that is, under the premise of stable scenario, the constructed target scheduling cost cache graph (including node configuration, edge weights, TaskMap mapping, and connectivity metadata) is serialized into a compact binary format (such as Protocol Buffers or a custom memory image) and stored offline to local disk or network storage; when subsequent tasks start, the entire graph structure is quickly restored through deserialization and directly enters the "reuse" process. This mechanism does not depend on the runtime context and is suitable for industrial scenarios such as pre-loading before production line changeover and multi-robot shared experience cache, further reducing cold start overhead.

[0086] (iv) Simplification of the scheduling cost cache graph: Determine if the number of nodes in the current scheduling cost cache graph has reached a preset upper limit. If so, based on one or more of the following: node connectivity, node density, and node historical attributes, prune the transitional nodes in the current scheduling cost cache graph to obtain a new current scheduling cost cache graph. The specific implementation process is as follows: First, obtain the total number of nodes in the current scheduling cost cache graph and compare it with the system's preset node upper limit threshold. If the number of nodes has reached the preset upper limit, the pruning process is triggered. Pruning is only performed on transitional nodes; critical nodes inserted during the current scheduling cost calculation are always retained and not removed. Pruning can be based on the following three types of indicators, either individually or in combination: (A) Low connectivity contribution: Calculate the frequency of each transition node being used for the shortest path between key nodes (i.e., the number of times the node appears on the effective path in historical queries), or the increase in the cost of the shortest path between key nodes caused by its removal (evaluated through local recalculation); remove several nodes with the lowest frequency or the smallest increase in impact. (B) High node density: In the configuration space, clustering (such as DBSCAN, using joint space distance as a metric) is performed on the transition node set to identify clusters with significantly higher density than the mean; within each high-density cluster, the node closest to the cluster center is retained, and the rest are removed in ascending order of distance. (C) Outdated node historical attributes: Record the "last active timestamp" of each transition node (i.e., the time when it was last visited by path search or when the edge weight was updated); prioritize removing "dormant nodes" that have not been visited for a long time (e.g., more than T=30 minutes) and are not located in the neighborhood of any key node; After selecting the set of transition nodes to be pruned according to the above rules, remove the node entities and all associated edges from the graph in batches, and update the adjacency structure and index simultaneously; after pruning, re-verify the connectivity of key nodes; if connectivity is damaged, insert new transition nodes to supplement the affected key node pairs.

[0087] In summary, in large-scale applications such as industrial robot measurement, traditional methods struggle to efficiently and accurately calculate the scheduling costs between massive task pairs within the robot's configuration space. On one hand, the computational complexity of precise path planning increases quadratically with the number of tasks. On the one hand, real-time performance cannot be guaranteed; on the other hand, existing approximation models (such as linear interpolation and fixed-weighted summation) suffer from severe distortion of cost values ​​due to neglecting the geometric constraints of the real feasible space and lacking physical interpretability, thus failing to support highly reliable scheduling decisions. The method provided by this invention fundamentally breaks through this bottleneck: by constructing a hierarchical and structured scheduling cost cache graph oriented towards the semantics of scheduling tasks, it achieves for the first time a scheduling cost calculation based on a complete configuration space, possessing physical meaning, and capable of system integration at the scale of thousands of tasks.

[0088] Compared to the widely used PRM (Probabilistic Roadmap) method, the method provided in this embodiment of the invention differs fundamentally in target localization, graph construction logic, and query mechanism: PRM is a general path planning technique. Its graph structure aims to "support path solving". Nodes are randomly sampled points, and edges are established by linear interpolation and collision detection. The edges are feasible paths. Its connectivity optimization is oriented towards the whole graph and requires a large number of samples and neighborhood connections. When the total number of nodes is limited, it is very easy to fall into the dilemma of low connectivity.

[0089] This invention is specifically designed for scheduling cost calculation. The graph structure is strictly organized around task requirements: nodes are clearly divided into two categories: "critical nodes" that are bound one-to-one with the measurement task, and "transition nodes" that are only used to ensure connectivity between critical nodes; edge weights are not approximate distances, but precisely calculated minimum feasible motion costs (such as execution time or energy), possessing clear physical dimensions and engineering interpretability; the construction process adopts a two-stage strategy of "task-driven - critical node anchoring - adding transition nodes as needed," and connectivity checks focus only on the critical node subgraph, avoiding the introduction of redundant nodes to improve global connectivity, ensuring task-level connectivity robustness even under strict node upper limit constraints; the query process completely eliminates the most time-consuming linear collision detection and nearest neighbor search, relying on... The TaskMap mapping with low complexity enables instantaneous location of tasks to key nodes, followed by a shortest path search within the graph to obtain the result. Combined with a lazy-update scheduling cost matrix, it significantly suppresses redundant computation.

[0090] Furthermore, the embodiments of this invention natively support multi-dimensional reuse: lightweight reuse at runtime can be achieved through node type conversion, and the cache graph can be serialized to disk for rapid loading and reuse in the same scenario; as the number of reuses increases, the key configurations that frequently appear in the graph and their connection relationships are continuously verified and strengthened, and the historically accumulated cost data gradually covers the motion hotspot areas in the workspace, so that the representation accuracy of the entire cache graph of the real scheduling cost shows a stable upward trend. This is a lightweight configuration space proxy model with adaptive evolution capabilities that is different from traditional offline modeling.

[0091] Based on the foregoing embodiments, this invention provides a scheduling cost determination apparatus for large-scale measurement tasks, see [link to previous document]. Figure 5 The diagram shows a structural schematic of a scheduling cost determination device for large-scale measurement tasks. The device mainly includes the following parts: Task receiving module 502 is used to receive a set of measurement tasks, which contains multiple scheduled tasks; The cache graph update module 504 is used to perform node type conversion and / or incremental node insertion on the current scheduling cost cache graph based on the scheduling task, and obtain the target scheduling cost cache graph after the connectivity condition is met. The nodes in the target scheduling cost cache graph are used to represent the points in the configuration space. They are divided into key nodes associated with scheduling tasks and transition nodes that connect key nodes. The value of the connection edge between nodes is used to represent the scheduling cost. The cost query module 506 is used to query the scheduling costs represented by the connecting edges in the target scheduling cost cache graph, in order to construct the scheduling cost matrix corresponding to the measurement task set.

[0092] The scheduling cost determination device for large-scale measurement tasks provided in this invention performs node type conversion and / or incremental node insertion on the scheduling cost cache graph, and obtains the target scheduling cost cache graph after passing the connectivity test, so that the scheduling cost cache graph dynamically evolves with the set of measurement tasks. In the target scheduling cost cache graph, the nodes represent points in the configuration space and are divided into key nodes and transition nodes. The value of the connecting edge directly represents the scheduling cost. Thus, the scheduling cost matrix can be constructed directly by querying the value of the connecting edge in the target scheduling cost cache graph. Therefore, in the scenario of large-scale task scheduling, the repeated traversal and calculation of the entire robot scheduling decision space is avoided. Moreover, as the scheduling cost cache graph evolves dynamically, only the local graph structure related to the incremental node insertion in the scheduling cost cache graph needs to be maintained, or even the scheduling cost cache graph does not need to be maintained, thereby significantly reducing the amount of computation and improving the efficiency of constructing the scheduling cost function.

[0093] In one implementation, the cache graph update module 504 is specifically used for: In the current scheduling cost cache graph, perform a nearest neighbor search on the scheduled task; If a transition node matching the scheduling task is determined through nearest neighbor search, a node type conversion is performed to convert the transition node into a key node corresponding to the scheduling task. If the nearest neighbor search determines that there is no transition node matching the scheduled task, perform incremental node insertion and insert the key node corresponding to the scheduled task into the current scheduling cost cache graph.

[0094] In one implementation, the cache graph update module 504 is specifically used for: Determine whether the connected components of the nodes in the current scheduling cost cache graph satisfy the connectivity condition, and if the result is negative, perform the following operation: If the total number of nodes in the current scheduling cost cache graph does not reach the upper limit, an insertion operation is performed on the current scheduling cost cache graph to insert the transition node that connects the key nodes into the current scheduling cost cache graph. An intermediate scheduling cost cache graph is obtained through neighbor node connection test, and then connectivity condition judgment is performed until the connectivity domain of any node in the intermediate scheduling cost cache graph meets the connectivity condition, and the target scheduling cost cache graph is obtained. Alternatively, if the total number of nodes in the current scheduling cost cache graph reaches the upper limit, then a connection operation is performed between the connected domains of the nodes in the current scheduling cost cache graph to obtain the target scheduling cost cache graph.

[0095] In one implementation, the cache graph update module 504 is specifically used for: Determine the number of first critical nodes contained in the current scheduling cost cache graph, and the number of second critical nodes contained in the node connectivity domains of the current scheduling cost cache graph; The connectivity index is determined based on the number of the first key nodes and the largest number of the second key nodes. If the connectivity index is greater than the preset index threshold, the connectivity condition is determined to be met.

[0096] In one implementation, the cache graph update module 504 is specifically used for: Determine the primary node's connectivity from the node connectivity components contained in the current scheduling cost cache graph; For any target node connected component in the current scheduling cost cache graph, excluding the master node connected component, perform sampling; If the target node's connected component and the master node's connected component satisfy the preset narrow channel condition, then perform the following operation: Based on the configuration space distance between any key node in the target node's connected domain and any key node in the master node's connected domain, multiple node pairs are determined; A specified path planner is used to perform path planning between each pair of nodes, and the specified path planner is different from the path planner used when the narrow passage condition is not met; Based on the execution status of path planning, and / or the total number of nodes contained in the current scheduling cost cache graph after path planning, an intermediate scheduling cost cache graph is obtained.

[0097] In one implementation, the cache graph update module 504 is specifically used for: If the path planning is successful and the total number of nodes has not reached the upper limit, then according to the result of the path planning, a transition node is inserted into the current scheduling cost cache graph. The inserted transition node and the key node contained in the node pair are connected and the value of the connection edge is updated to obtain the intermediate scheduling cost cache graph. If the path planning is successful and the total number of nodes reaches the upper limit, then connect the key nodes contained in the node pair and update the value of the connection edge to obtain the intermediate scheduling cost cache graph. If path planning fails for each node, it is determined that the target node's connected domain and the master node's connected domain are not connected.

[0098] In one implementation, the cost query module 506 is specifically used for: For any two scheduled tasks, query the cost status between the two scheduled tasks; If the cost state is known, read the scheduling cost between the two scheduled tasks; When the cost state is unknown, the target scheduling cost cache graph is mapped twice based on the association between the scheduling task and the key node; Based on the result of the two mappings, a shortest path search is performed on the two scheduling tasks in the target scheduling cost cache graph to obtain the scheduling cost between the two scheduling tasks, and the cost state is set to a known state. Based on the scheduling cost between two scheduling tasks, construct the scheduling cost matrix corresponding to the measurement task set.

[0099] In one implementation, a cache graph reuse module is also included, for: After constructing the scheduling cost matrix corresponding to the set of measurement tasks, all nodes in the target scheduling cost cache graph are reset to transition nodes to obtain a new current scheduling cost cache graph, so that the new scheduling cost cache graph can be reused when a new set of measurement tasks is received.

[0100] In one implementation, a cached graph clipping module is also included, for: Determine whether the number of nodes in the current scheduling cost cache graph has reached the preset upper limit; If so, then based on one or more of the node connectivity, node density, and node historical attributes in the current scheduling cost cache graph, the transition nodes contained in the current scheduling cost cache graph are pruned to obtain a new current scheduling cost cache graph.

[0101] The device provided in this embodiment of the invention has the same implementation principle and technical effect as the aforementioned method embodiment. For the sake of brevity, any parts not mentioned in the device embodiment can be referred to the corresponding content in the aforementioned method embodiment.

[0102] This invention provides an electronic device, specifically, the electronic device includes a processor and a memory; the memory stores a computer program, which, when run by the processor, executes the method described in any of the above embodiments.

[0103] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention. The electronic device 100 includes: a processor 60, a memory 61, a bus 62, and a communication interface 63. The processor 60, the communication interface 63, and the memory 61 are connected through the bus 62. The processor 60 is used to execute executable modules, such as computer programs, stored in the memory 61.

[0104] The memory 61 may include high-speed random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Communication between this system network element and at least one other network element is achieved through at least one communication interface 63 (which can be wired or wireless), such as the Internet, wide area network, local area network, metropolitan area network, etc.

[0105] Bus 62 can be an ISA bus, PCI bus, or EISA bus, etc. The bus can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 6 The symbol is represented by a single double-headed arrow, but this does not mean that there is only one bus or one type of bus.

[0106] The memory 61 is used to store programs. After receiving an execution instruction, the processor 60 executes the program. The method executed by the device for defining the flow process disclosed in any of the foregoing embodiments of the present invention can be applied to the processor 60 or implemented by the processor 60.

[0107] Processor 60 may be an integrated circuit chip with signal processing capabilities. In implementation, each step of the above method can be completed by the integrated logic circuitry in the hardware of processor 60 or by instructions in software form. Processor 60 can be a general-purpose processor, including a Central Processing Unit (CPU), a Network Processor (NP), etc.; it can also be a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field-Programmable Gate Array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this invention. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this invention can be directly embodied in the execution of a hardware decoding processor, or executed by a combination of hardware and software modules in the decoding processor. The software modules can reside in random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, or other mature storage media in the art. The storage medium is located in memory 61. Processor 60 reads the information in memory 61 and, in conjunction with its hardware, completes the steps of the above method.

[0108] The computer program product of the readable storage medium provided in the embodiments of the present invention includes a computer-readable storage medium storing program code. The instructions included in the program code can be used to execute the methods described in the foregoing method embodiments. For specific implementation, please refer to the foregoing method embodiments, which will not be repeated here.

[0109] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0110] Finally, it should be noted that the above-described embodiments are merely specific implementations of the present invention, used to illustrate the technical solutions of the present invention, and not to limit it. The scope of protection of the present invention is not limited thereto. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments within the technical scope disclosed in the present invention, or make equivalent substitutions for some of the technical features; and these modifications, changes, or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A method for determining a scheduling cost for a large-scale measurement task, characterized by, include: Receive a set of measurement tasks, which includes multiple scheduled tasks; Based on the scheduling task, node type conversion and / or incremental node insertion are performed on the current scheduling cost cache graph, and a target scheduling cost cache graph is obtained after the connectivity condition is met. The nodes in the target scheduling cost cache graph are used to represent points in the configuration space. They are divided into key nodes associated with the scheduling task and transition nodes that connect the key nodes. The values ​​corresponding to the connecting edges between the nodes are used to represent the scheduling cost. The scheduling cost represented by the connecting edge in the target scheduling cost cache graph is queried to construct the scheduling cost matrix corresponding to the measurement task set.

2. The method according to claim 1, wherein, Based on the scheduling task, perform node type conversion and / or incremental node insertion on the current scheduling cost cache graph, including: In the current scheduling cost cache graph, a nearest neighbor search is performed on the scheduled task; If the nearest neighbor search determines that there is a transition node that matches the scheduling task, a node type conversion is performed to convert the transition node into a key node corresponding to the scheduling task. If the nearest neighbor search determines that there is no transition node matching the scheduling task, incremental node insertion is performed to insert the key node corresponding to the scheduling task into the current scheduling cost cache graph.

3. The method according to claim 1, wherein, After satisfying the connectivity conditions, the target scheduling cost cache graph is obtained, including: Determine whether the node connectivity components in the current scheduling cost cache graph satisfy the connectivity condition, and if the determination result is negative, perform the following operation: If the total number of nodes in the current scheduling cost cache graph does not reach the upper limit, an insertion operation is performed on the current scheduling cost cache graph to insert the transition node into the current scheduling cost cache graph. An intermediate scheduling cost cache graph is obtained through neighbor node connection testing. Then, a connectivity condition judgment is performed until any node in the intermediate scheduling cost cache graph satisfies the connectivity condition, and the target scheduling cost cache graph is obtained. Alternatively, if the total number of nodes in the current scheduling cost cache graph reaches the upper limit, then a connection operation is performed between the connected domains of the nodes in the current scheduling cost cache graph to obtain the target scheduling cost cache graph.

4. The scheduling cost determination method for large-scale measurement tasks according to claim 3, characterized in that, Determine whether the node connectivity components in the current scheduling cost cache graph satisfy the connectivity condition: Determine the number of first key nodes contained in the current scheduling cost cache graph, and the number of second key nodes contained in the node connectivity domain of the current scheduling cost cache graph; A connectivity index is determined based on the first number of key nodes and the largest number of second key nodes, and if the connectivity index is greater than a preset index threshold, the connectivity condition is determined to be met.

5. The scheduling cost determination method for large-scale measurement tasks according to claim 3, characterized in that, An insertion operation is performed on the current scheduling cost cache graph to insert the transition node into the current scheduling cost cache graph. An intermediate current scheduling cost cache graph is obtained through neighbor node connection testing, including: The primary node connectivity is determined from the node connectivity contained in the current scheduling cost cache graph; For any target node connected component in the current scheduling cost cache graph other than the master node connected component, sampling is performed; If the target node's connected component and the master node's connected component satisfy a preset narrow channel condition, then the following operation is performed: Based on the configuration space distance between any key node in the target node's connected domain and any key node in the main node's connected domain, multiple node pairs are determined; A specified path planner is used to perform path planning between each pair of nodes, and the specified path planner is different from the path planner used when the narrow passage condition is not met; Based on the execution status of the path planning, and / or the total number of nodes contained in the current scheduling cost cache graph after the path planning, an intermediate scheduling cost cache graph is obtained through neighbor node connection testing.

6. The scheduling cost determination method for large-scale measurement tasks according to claim 5, characterized in that, Based on the execution status of the path planning, and / or the total number of nodes contained in the current scheduling cost cache graph after the path planning, an intermediate scheduling cost cache graph is obtained through neighbor node connection testing, including: If the path planning is successfully executed and the total number of nodes has not reached the upper limit, then according to the result of the path planning, the transition node is inserted into the current scheduling cost cache graph, the inserted transition node and the key node contained in the node pair are connected and the value corresponding to the connection edge is updated to obtain the intermediate scheduling cost cache graph. If the path planning is successfully executed and the total number of nodes reaches the upper limit, then the nodes included in the node pair are connected and the value corresponding to the connection edge is updated to obtain the intermediate scheduling cost cache graph. If the path planning performed on each of the node pairs fails, it is determined that the target node's connected domain and the master node's connected domain are not connected.

7. The scheduling cost determination method for large-scale measurement tasks according to claim 1, characterized in that, Querying the scheduling costs represented by the connecting edges in the target scheduling cost cache graph to construct the scheduling cost matrix corresponding to the measurement task set includes: For any two scheduled tasks, query the cost status between the two scheduled tasks; If the cost state is known, read the scheduling cost between the two scheduled tasks; When the cost state is unknown, the target scheduling cost cache graph is mapped twice based on the association between the scheduling task and the key node; Based on the result of the two mappings, a shortest path search is performed on the two scheduling tasks in the target scheduling cost cache graph to obtain the scheduling cost between the two scheduling tasks, and the cost state is set to the known state. Based on the scheduling cost between the two scheduling tasks, a scheduling cost matrix corresponding to the measurement task set is constructed.

8. The method for determining scheduling costs for large-scale measurement tasks according to claim 1, characterized in that, The method further includes: After constructing the scheduling cost matrix corresponding to the measurement task set, all nodes contained in the target scheduling cost cache graph are reset to the transition nodes to obtain a new current scheduling cost cache graph, so as to reuse the new scheduling cost cache graph when a new measurement task set is received.

9. The scheduling cost determination method for large-scale measurement tasks according to claim 1, characterized in that, The method further includes: Determine whether the number of nodes in the current scheduling cost cache graph has reached a preset upper limit. If so, the transition nodes contained in the current scheduling cost cache graph are pruned based on one or more of the node connectivity, node density, and node history attributes in the current scheduling cost cache graph to obtain a new current scheduling cost cache graph.

10. A scheduling cost determination device for large-scale measurement tasks, characterized in that, include: The task receiving module is used to receive a set of measurement tasks, which includes multiple scheduled tasks. The cache graph update module is used to perform node type conversion and / or incremental node insertion on the current scheduling cost cache graph based on the scheduling task, and obtain the target scheduling cost cache graph after the connectivity condition is met. The nodes in the target scheduling cost cache graph are used to represent points in the configuration space. They are divided into key nodes associated with the scheduling task and transition nodes that connect the key nodes. The value of the connection edge between the nodes is used to represent the scheduling cost. The cost query module is used to query the scheduling cost represented by the connecting edge in the target scheduling cost cache graph, so as to construct the scheduling cost matrix corresponding to the measurement task set.

11. An electronic device, characterized in that, The method includes a processor and a memory, the memory storing computer-executable instructions executable by the processor, the processor executing the computer-executable instructions to implement the method of any one of claims 1 to 9.

Images