Robot path planning method and device, electronic equipment and storage medium

Abstract

The application relates to the technical field of robots, and provides a robot path planning method and device, electronic equipment and a storage medium, the method comprising: in the path planning process of a robot, starting multiple parallel path planning threads, and assigning different deterministic sampling sequences to each path planning thread; in each path planning thread, performing path search based on the deterministic sampling sequence; in response to any path planning thread successfully planning an initial path, terminating all path planning threads, and performing backtracking optimization on the initial path to obtain a motion path of the robot. The application effectively overcomes the problems of inconsistent planning results and poor real-time performance of traditional random sampling by using deterministic sampling sequences and multi-thread parallel search; the path quality is improved while the efficiency is ensured through backtracking optimization. Under the premise that the environment does not change, the consistency of the path planning result is achieved, and the optimality and calculation efficiency of the path planning result are improved.

Description

Technical Field

[0001] This application relates to the field of robotics, and in particular to robot path planning methods, apparatus, electronic devices, and storage media. Background Technology

[0002] Currently, robot path planning methods are generally divided into three main categories: metaheuristic algorithms, graph search algorithms, and sampling-based algorithms. Among them, metaheuristic algorithms and graph search algorithms suffer from drawbacks such as high computational complexity, curse of dimensionality, and poor real-time performance, while traditional sampling-based algorithms suffer from poor consistency of planning results and unstable path quality, making them difficult to apply in medical-related scenarios.

[0003] In medical robot applications, the consistency of planning results is crucial. If performing the same planning task twice, even without changes in the environment, generates two completely different paths, it can affect the doctor's operation. Therefore, improving the consistency of path planning results is an urgent problem to be solved. Summary of the Invention

[0004] This application aims to address at least one of the technical problems existing in the prior art. To this end, this application proposes a robot path planning method that achieves consistency in path planning results without changing the environment, while improving the optimality and computational efficiency of the path planning results.

[0005] This application also proposes a robot path planning device, electronic equipment, and a non-transitory computer-readable storage medium.

[0006] The robot path planning method according to the first aspect of this application includes: During the robot's path planning process, multiple parallel path planning threads are initiated, and a different deterministic sampling sequence is assigned to each path planning thread; wherein, with the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by the standard pseudo-random number generator. In each of the path planning threads, a path search is performed based on the deterministic sampling sequence; In response to any of the path planning threads successfully planning an initial path, all path planning threads are terminated, and the initial path is backtracked and optimized to obtain the robot's motion path.

[0007] According to one embodiment of this application, the step of performing path search based on the deterministic sampling sequence in each path planning thread includes: Initialize the tree structure for each path planning thread; the initial node of the tree structure corresponds to the starting state of the robot; In each of the path planning threads, sampling points are generated based on the deterministic sampling sequence; In the tree structure maintained by each path planning thread, find the node closest to the sampling point, and expand new nodes from the nearest node toward the sampling point; If the new node meets the collision-free condition, then the new node is added to the tree structure, and parent node optimization and rewiring operations are performed on the tree structure. Repeat the tree growth and optimization operation based on the deterministic sampling sequence until any of the path planning threads successfully plans the initial path.

[0008] According to one embodiment of this application, the step of performing parent node optimization and rerouting operations on the tree structure includes: Using the new node as the center, search for a set of nodes within a neighborhood of a preset radius; Calculate the first path cost from the initial node to the new node via each neighboring node in the node set, and determine the node with the minimum first path cost as the parent node of the new node; For each of the neighboring nodes, calculate the second path cost to reach the neighboring node through the new node; If the cost of the second path is less than the original cost of the neighboring node, the parent node of the neighboring node is updated to the new node.

[0009] According to one embodiment of this application, the step of backtracking optimization of the initial path to obtain the robot's motion path includes: Backtracking is performed from the target node to the initial node along the initial path; the target node is the end node of the initial path, corresponding to the target state of the robot; During the backtracking process, the connection relationships between path nodes are optimized by local rewiring to obtain the robot's motion path.

[0010] According to one embodiment of this application, the step of optimizing the local rewiring of the connection relationships between path nodes during the backtracking process to obtain the motion path of the robot includes: During the backtracking process, if the current backtracking node has a grandparent node, a collision-free test is performed between the current backtracking node and the grandparent node. If there is no collision on the straight path from the grandparent node to the current backtracking node, then the parent node of the current backtracking node is updated to the grandparent node, thereby removing the parent node from the initial path.

[0011] According to one embodiment of this application, the deterministic sampling sequence is generated based on any of the following methods: Each path planning thread is assigned a different prime number base, and the deterministic sampling sequence is generated based on the prime number base; The deterministic sampling sequence is generated based on the benchmark sampling sequence through complementary operations; The prime number base of the reference sampling sequence is reversed, and the deterministic sampling sequence is generated based on the reversed prime number base.

[0012] According to one embodiment of this application, the starting state and target state of the robot are determined based on the following method; Receive target pose command; Based on the target pose command and the robot's current pose, the robot's starting state and target state are obtained through inverse kinematics calculations.

[0013] A robot path planning apparatus according to a second aspect embodiment of this application includes: The thread startup module is used to start multiple parallel path planning threads during the robot's path planning process, and to assign different deterministic sampling sequences to each of the path planning threads; wherein, under the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by the standard pseudo-random number generator. The path search module is used to perform path search based on the deterministic sampling sequence in each of the path planning threads; The path planning module is used to terminate all path planning threads and backtrack to optimize the initial path in response to any path planning thread successfully planning an initial path, thereby obtaining the motion path of the robot.

[0014] An electronic device according to a third aspect of this application includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the robot path planning method as described above.

[0015] A non-transitory computer-readable storage medium according to a fourth aspect of this application stores a computer program thereon, which, when executed by a processor, implements the robot path planning method as described above.

[0016] The above-described one or more technical solutions in the embodiments of this application have at least one of the following technical effects: By employing deterministic sampling sequences and multi-threaded parallel search, the problems of inconsistent results and poor real-time performance in traditional random sampling planning are effectively overcome. Through backtracking optimization, path quality is systematically improved while maintaining efficiency. Based on this, consistency of path planning results is achieved without changes in the environment, while simultaneously improving the optimality and computational efficiency of the path planning results.

[0017] Additional aspects and advantages of this application will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is one of the flowcharts illustrating the robot path planning method provided in the embodiments of this application.

[0020] Figure 2 This is an architecture diagram of the robot path planning system provided in the embodiments of this application.

[0021] Figure 3 This is the second flowchart illustrating the robot path planning method provided in the embodiments of this application.

[0022] Figure 4 This is a schematic diagram of the simulation environment provided in the embodiments of this application.

[0023] Figure 5 This is a schematic diagram of the robot path planning device provided in the embodiments of this application.

[0024] Figure 6 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0025] The embodiments of this application will be described in further detail below with reference to the accompanying drawings and examples. The following examples are used to illustrate this application, but should not be used to limit the scope of this application.

[0026] Figure 1 This is a flowchart illustrating the robot path planning method provided in an embodiment of this application. (Refer to...) Figure 1 This application provides a robot path planning method, including: Step 101: During the robot's path planning process, multiple parallel path planning threads are started, and a different deterministic sampling sequence is assigned to each path planning thread.

[0027] A path planning thread is an independent instance of path search execution. Each thread instance has its own deterministic sampling sequence and independently maintained tree structure, and executes path search from a common starting point to a common destination in parallel within a shared environment model. Multiple path planning threads execute concurrently, constituting a parallel search.

[0028] Deterministic sampling sequences are low-discrepancy sequences, meaning that the resulting set of sample points exhibits a low degree of spatial non-uniformity, far superior to purely random sampling. It should be understood that for a given number of sample points N, the upper bound of the discrepancy of the point set generated by the deterministic sequence within a unit hypercube is significantly lower. This mathematical property allows low-discrepancy sequences to produce more spatially uniformly distributed sample points with the same number of sampling attempts, thus achieving more efficient and consistent spatial exploration in path planning. Specifically, with the same number of samples, the uniformity of the distribution of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than that of the sample point set generated by a standard pseudo-random number generator. This standard pseudo-random number generator can be a linear congruence generator or a Mason tween rotation generator. It should be understood that higher uniformity results in a more comprehensive coverage of the overall configuration space by the sample point sets generated by different planning threads, thereby improving parallel search efficiency. Furthermore, higher uniformity ensures greater repeatability of the spatial distribution of sample points when planning is executed multiple times under the same environment, thus guaranteeing the consistency of path planning results.

[0029] The low-difference sequence can be a Halton sequence. Alternatively, the low-difference sequence can also be a Sobol sequence or a Faure sequence.

[0030] It should be noted that traditional methods generate path points randomly. This embodiment uses multidimensional Halton sequences to generate low-discretion pseudo-random sequences for path point generation, ensuring consistency of planning results even when the environment remains unchanged. Furthermore, Halton sequences offer advantages such as low-discretion distribution, good dimensional scalability, and high computational efficiency, further improving planning quality and efficiency. Additionally, a multi-threaded parallel computation method is employed during the planning process, using different Halton sequences in different threads. By setting an appropriate prime number base, low spatial repetition between different Halton sequences is ensured, thereby improving spatial search efficiency. Once a path is successfully planned in a thread, computation stops and the result is adopted, minimizing the overall planning time.

[0031] Launch multiple parallel path planning threads. For example, determine the number N to be created based on the number of processor cores of the computing device available for path planning or a preset concurrency parameter, where N is an integer greater than 1; create N independent thread instances and allocate an independent memory workspace to each thread instance; initialize a dedicated tree structure for each thread instance and set the robot's current state as the root node of the tree, where the tree structures of different threads are isolated from each other; assign each thread instance to an independent logical execution unit or processor core and load shared, read-only environment model data for each thread to perform collision detection; synchronously launch all N thread instances through the operating system's thread scheduler or parallel computing framework, allowing them to concurrently execute their respective path search tasks; create a global state listener or set a shared flag variable to monitor the planning completion status of any thread instance in real time.

[0032] Each path planning thread is assigned a different deterministic sampling sequence. For example, based on a pre-defined prime number table or low-discrepancy sequence generation algorithm, M different sets of generation parameters are pre-calculated and stored, where M is not less than the number of path planning threads N. For each started path planning thread, a set of exclusive generation parameters is dynamically allocated from the parameter pool or statically specified, ensuring that the sets of generation parameters allocated to any two threads are different. During the initialization phase of each path planning thread, based on the exclusive generation parameters allocated to that thread, a deterministic sampling sequence specific to that thread is generated in real time or loaded from a pre-calculation library. The generated deterministic sampling sequence is encapsulated and bound to the corresponding path planning thread context in the form of a data structure or function object, serving as the sole sampling source invoked by that thread when performing path search.

[0033] Step 102: In each of the path planning threads, a path search is performed based on the deterministic sampling sequence.

[0034] Path search is achieved using a fast exploratory random tree algorithm driven by a deterministic sampling sequence.

[0035] In each path planning thread, path search is performed based on a deterministic sampling sequence by iteratively executing the following steps: generating sampling points based on the sequence to guide the expansion of the tree structure, and performing connection optimization in the local neighborhood of the new nodes generated by the expansion to reduce path costs.

[0036] Step 103: In response to any of the path planning threads successfully planning an initial path, all path planning threads are terminated, and the initial path is backtracked and optimized to obtain the robot's motion path.

[0037] It should be noted that the embodiments of this application employ an improved RRT. The Rapidly-exploring Random TreeStar (RRT) algorithm is used for path planning. Specifically, in the improved RRT... In the algorithm, in addition to setting parent node optimization and rewiring during the search process, the parent and grandparent nodes are optimized again and rewiring is performed again during the backtracking process from the target point to the starting point after convergence to the target point. This further improves the optimality of the result without affecting the computational efficiency.

[0038] Backtracking optimization refers to traversing backwards along the initial path from the target node to the starting node and reconstructing the node connections to shorten the path length. Backtracking optimization is performed in a local subgraph consisting of the nodes of the initial path and their neighboring nodes in the tree structure.

[0039] A competition logic is established among multiple parallel threads, where the first thread to meet the success criteria triggers a global interrupt event, forcing all other parallel threads to immediately exit their search loops. For example, the planning status of each path planning thread is polled in real-time or periodically via a global state listener, inter-thread communication messages, or shared memory flags. When a thread reports that its planning status meets the following condition, it is considered to have successfully planned an initial path: a collision-free continuous path has been constructed from the root node to that node. Once a thread is determined to have succeeded, a global termination signal is immediately broadcast to all running path planning threads, or a shared termination flag accessible to all threads is set. Upon receiving the termination signal or detecting the termination flag, each path planning thread immediately interrupts its current iteration, saves necessary results, and releases the occupied computing resources.

[0040] Starting from the end node of the initial path, check the nodes on the path sequentially towards the starting node. For the current backtracking node, if its grandparent node exists, verify whether the straight line connection from the grandparent node to the current node satisfies the collision-free condition. If it does, update the parent node of the current node to the grandparent node, thereby shortening the path. Use the grandparent node as the new current backtracking node and repeat the above checking and updating process until the starting node is reached.

[0041] The robot path planning method provided in this application starts multiple parallel path planning threads during the robot's path planning process and assigns a different deterministic sampling sequence to each thread. Under the same sampling quantity, the uniformity of the distribution of sampling points generated by the deterministic sampling sequence in the configuration space is higher than that of the sampling point set generated by a standard pseudo-random number generator. In each path planning thread, path search is performed based on the deterministic sampling sequence. In response to any path planning thread successfully planning an initial path, all path planning threads are terminated, and the initial path is backtracked and optimized to obtain the robot's motion path. This application effectively overcomes the problems of inconsistent results and poor real-time performance of traditional random sampling planning by employing deterministic sampling sequences and multi-threaded parallel search. Through backtracking optimization, path quality is systematically improved while maintaining efficiency. Based on this, consistency of path planning results is achieved without environmental changes, while simultaneously improving the optimality and computational efficiency of the path planning results.

[0042] Based on the above embodiments, the step of performing path search based on the deterministic sampling sequence in each path planning thread includes: Initialize the tree structure for each of the path planning threads; In each of the path planning threads, sampling points are generated based on the deterministic sampling sequence; In the tree structure maintained by each path planning thread, find the node closest to the sampling point, and expand new nodes from the nearest node toward the sampling point; If the new node meets the collision-free condition, then the new node is added to the tree structure, and parent node optimization and rewiring operations are performed on the tree structure. Repeat the tree growth and optimization operation based on the deterministic sampling sequence until any of the path planning threads successfully plans the initial path.

[0043] The initial node (i.e., the root node, the starting node) of the tree structure corresponds to the robot's starting state; where the starting state is the robot's configuration in joint space, such as the joint angle vector.

[0044] Initialize the tree structure for each path planning thread. For example, create an empty tree structure and insert the node representing the robot's current state (q_init) as the unique root node of the tree. The root node is marked as visited and its path cost is zero. Each thread's tree structure is assigned a unique thread identifier, which is used to distinguish and track the search results of different threads in a parallel computing environment.

[0045] Optionally, initializing the tree structure also includes initializing a data structure for spatial indexing of the tree to support fast nearest neighbor queries for nodes in the tree. Additionally, the memory space of the tree structure initialized for each thread is physically or logically isolated from the tree structures of other threads.

[0046] In each path planning thread, sampling points are generated based on a deterministic sampling sequence. For example, the current internal state of the deterministic sampling sequence assigned to the current path planning thread is obtained. Based on this current internal state, a deterministic iterative calculation is performed to generate a standard sampling vector. Each component of the standard sampling vector is linearly or nonlinearly scaled and offset according to the actual range of motion of each joint of the robot to obtain a specific sampling point q_H in the robot configuration space. The internal state is updated according to the predefined rules of the deterministic sampling sequence to ensure that the next iteration will generate a different sampling point.

[0047] In the tree structure maintained by each path planning thread, the node closest to the sampling point is found, and a new node is extended from the nearest node towards the sampling point. For example, the node distance is defined using a metric in configuration space (such as Euclidean distance), and a nearest neighbor search is performed through the spatial index data structure associated with the tree structure to obtain the tree node q_near closest to the sampling point q_H; the direction vector from q_near to q_H is calculated, and this vector is normalized and multiplied by a preset fixed step size δ or an adaptive step size to obtain the extended vector; the extended vector is added to the coordinates of q_near to obtain the coordinates of the candidate new node q_new in configuration space; q_new is verified by joint constraints and velocity / acceleration constraints, and if q_new exceeds any constraint range, its coordinates are pruned to the constraint boundary; in the digital twin environment, continuous collision detection is performed on the path segment from q_near to q_new.

[0048] If a new node satisfies the collision-free condition, it is added to the tree structure, and parent node optimization and rerouting operations are performed. Parent node optimization refers to finding and selecting the lowest-cost connection path from the origin to q_new within its neighborhood when a new node q_new is added to the tree. This means the new node is not necessarily connected to the geometrically closest node, but rather to the node that minimizes the global path cost. Rerouting involves, after determining the parent node of the new node q_new, checking whether q_new can become a better parent node for existing nodes in its neighborhood—that is, whether it can provide a lower-cost path from the origin to these existing nodes. If so, the existing connections are changed, and these existing nodes are rerouted to q_new.

[0049] Repeat the tree growth and optimization operations based on the deterministic sampling sequence until any path planning thread successfully plans the initial path. For example, this can be achieved using the following loop: (1) Single iteration execution: Perform the following operations sequentially in the current thread: Based on the deterministic sampling sequence allocated to this thread, generate the sampling point q_H for the current iteration; find the node q_near that is closest to q_H in the tree, and extend a new node q_new along the direction from q_near to q_H; verify whether the path segment from q_near to q_new satisfies the collision-free condition; if the verification passes, add q_new to the tree, and perform parent node optimization and rewire operation; (2) Continuous monitoring of success conditions: After each iteration, check whether there is a node q_reach in the tree structure of the current thread that meets the following conditions: the distance between node q_reach and the target state q_goal is less than the preset threshold ε; there is a continuous collision-free path from the root node to q_reach; (3) Loop termination: If condition (2) is detected to be satisfied, the loop iteration of the current thread is terminated immediately, and the path from the root node to q_reach is marked as the initial path successfully planned by the thread; otherwise, return to step (1) to continue the next iteration.

[0050] This application's embodiments allocate a unique deterministic sampling sequence to each parallel thread and make it deeply drive the RRT. The algorithm's complete iterative loop transforms traditional random exploration into a predictable deterministic search, thereby simultaneously ensuring high consistency of planning results, real-time response, and optimal path quality.

[0051] Based on the above embodiments, the step of performing parent node optimization and rerouting operations on the tree structure includes: Using the new node as the center, search for a set of nodes within a neighborhood of a preset radius; Calculate the first path cost from the initial node to the new node via each neighboring node in the node set, and determine the node with the minimum first path cost as the parent node of the new node; For each of the neighboring nodes, calculate the second path cost to reach the neighboring node through the new node; If the cost of the second path is less than the original cost of the neighboring node, the parent node of the neighboring node is updated to the new node.

[0052] In one embodiment, performing parent node optimization and rewiring operations on a tree structure can be achieved through the following steps: S1. Taking the new node q_new as the center, determine a spherical neighborhood with radius r in the configuration space, and use the spatial index of the tree structure to find all existing nodes located in this neighborhood to form a node set Q_near; S2. For each neighboring node q_near in Q_near, perform the following steps: Calculate the first path cost Cost(q_near) + Distance(q_near,q_new) from the initial node through q_near to q_new; verify whether the straight path from q_near to q_new satisfies the collision-free condition; from all neighboring nodes that satisfy the collision condition, select the node that minimizes the first path cost as the optimal parent node of q_new, and add q_new to the tree, connecting it to the parent node; S3. For each node q_near in Q_near (excluding q_new itself and its new parent node), perform the following steps: Calculate the potential second path cost Cost(q_new) + Distance(q_new, q_near) from the root node via q_new to q_near; verify whether the straight path from q_new to q_near satisfies the collision-free condition; if the second path cost is less than the cost Cost(q_near) currently recorded in q_near and the collision detection passes, then reconnect the parent node of q_near to q_new, and update the path cost of q_near and all its downstream nodes.

[0053] S4. After completing the parent node selection and rewiring, update the spatial index of the tree structure and include q_new in the index range.

[0054] This application embodiment optimizes the parent node and rewires the tree structure, enabling the search tree to continuously self-optimize during its growth and reduce path costs. This ensures that each expansion makes the overall path better, achieving simultaneous search and optimization.

[0055] Based on the above embodiments, the step of backtracking and optimizing the initial path to obtain the robot's motion path includes: Backtrack from the target node to the initial node along the initial path; During the backtracking process, the connection relationships between path nodes are optimized by local rewiring to obtain the robot's motion path.

[0056] The target node is the end node of the initial path, corresponding to the target state of the robot; where the target state is the robot joint angle vector q_goal obtained by inverse kinematics calculation. The target state corresponds to the target pose that the robot needs to reach. For example, in the robot configuration space (such as joint space), it is a specific robot posture configuration that corresponds to the task to be completed (such as reaching a specific position or performing a specific operation).

[0057] The robot backtracks from the target node to the initial node along the initial path. During this backtracking process, local rewiring optimization is performed on the connections between path nodes to obtain the robot's motion path. It should be understood that the connections between path nodes refer to the pointing relationships between ordered nodes on the path, defined by the parent node pointers in the tree structure. Local rewiring optimization refers to, during the backtracking process, attempting to replace the parent node of the current node with its grandparent node, and updating the connections when safety conditions are met, thereby shortening the path.

[0058] This application embodiment identifies and eliminates redundant turning points in the path by tracing back along the planned path and locally reconstructing node connections without re-performing a global search. This effectively shortens the path length and improves the path smoothness without significantly increasing computational overhead, thereby quickly refining an initial feasible path into a better final execution path that meets the requirements of efficient and safe robot movement.

[0059] Based on the above embodiments, the step of optimizing the local rewiring of the connection relationships between path nodes during the backtracking process to obtain the robot's motion path includes: During the backtracking process, if the current backtracking node has a grandparent node, a collision-free test is performed between the current backtracking node and the grandparent node. If there is no collision on the straight path from the grandparent node to the current backtracking node, then the parent node of the current backtracking node is updated to the grandparent node, thereby removing the parent node from the initial path.

[0060] During the backtracking process, it is determined whether the current backtracking node has a grandparent node. If it does, a collision-free test is performed between the current backtracking node and the grandparent node. For example, in the robot's configuration space, a straight line segment L is constructed from the grandparent node q_grandparent to the current backtracking node q_current. In the digital twin environment model, continuous collision detection is performed on the straight line segment L, specifically including: sampling along the line segment L with a preset discrete resolution or adaptive step size to obtain a series of intermediate configurations {q_interp}; for each intermediate configuration q_interp, the collision detection engine is called to determine whether the robot model with that configuration as its joint angle interferes with obstacles in the environment; at the same time, it is verified whether the robot satisfies kinematic constraints (such as joint limits and link interference) when moving from q_grandparent to q_current through each intermediate configuration. If all intermediate configurations q_interp do not interfere with the environment and satisfy all kinematic constraints, the collision-free test is considered passed; otherwise, it is considered failed.

[0061] If there is no collision on the straight path from the grandparent node to the current backtracking node, then the parent node of the current backtracking node is updated to the grandparent node to remove the parent node from the initial path. For example, in a tree structure, the parent node pointer of the current backtracking node q_current is modified from its original parent node q_parent to point to the grandparent node q_grandparent; the path cost of q_current is recalculated, and the new cost is the path cost of the grandparent node q_grandparent plus the straight line distance from q_grandparent to q_current; based on the updated parent node pointer, the parent pointer chain is retraced from the target node, and the resulting new node sequence is the optimized motion path, in which the original parent node q_parent no longer appears in the pointer chain.

[0062] In one embodiment, the digital twin environment model used in path planning can be dynamically constructed and determined in the following way: Real-time acquisition of dynamic 3D point cloud data and semantic information, including obstacles, medical equipment, and personnel, using 3D vision sensors (such as depth cameras and LiDAR) deployed in the medical scene and a pre-recorded medical equipment model database; The 3D point cloud data is then compared with pre-operatively acquired medical imaging models (such as CT (Computed Tomography) and MRI (Magnetic Resonance Imaging) models). The system performs registration and fusion of imaging (magnetic resonance imaging) to accurately mark the static positions of key anatomical structures (such as blood vessels, nerves, and lesions) in a dynamic point cloud. Using computer vision algorithms, it identifies and segments movable obstacles (such as healthcare workers' hands or moving instruments) from the fused point cloud, and builds a simplified kinematic model (such as a bounding box or cylinder) for each identified dynamic obstacle and predicts its short-term trajectory. The registered static anatomical structure model, the identified dynamic obstacle model and its motion prediction, and the 3D model of fixed medical equipment loaded from the database are integrated into a 3D scene graph with a global coordinate system. This scene graph is the digital twin environment model used for path planning and collision detection. A real-time synchronization mechanism is established between the digital twin environment model and the real physical environment to receive sensor data at a preset frequency and update the position and state of dynamic obstacles in the model to ensure consistency between the model and the real environment.

[0063] This application embodiment safely skips redundant intermediate parent nodes, thereby efficiently shortening the path length and simplifying the path shape without replanning, ultimately resulting in a better motion trajectory.

[0064] Based on the above embodiments, the deterministic sampling sequence is generated in any of the following ways: Each path planning thread is assigned a different prime number base, and the deterministic sampling sequence is generated based on the prime number base; The deterministic sampling sequence is generated based on the benchmark sampling sequence through complementary operations; The prime number base of the reference sampling sequence is reversed, and the deterministic sampling sequence is generated based on the reversed prime number base.

[0065] A prime base is a set of prime numbers used to generate a Halton sequence in one dimension. A D-dimensional Halton sequence is uniquely determined by a set of D distinct prime bases. Different threads can generate distinct deterministic sampling sequences by being assigned different combinations of prime bases.

[0066] By configuring a set of distinct prime numbers for each thread and using these as parameters to drive the Halton sequence generator, a deterministic sampling sequence specific to each thread is generated. For example, a set of prime numbers P={p1,p2,...,pM} containing at least M distinct prime numbers is predefined, where M is not less than the product of the planning dimension D and the number of threads N; simultaneously, a set of exclusive prime number basis vectors B of dimension D is assigned to the k-th path planning thread (k=1,2,...,N). k =[b k1 ,b k2 ,...,b kD ], where each element b in the vector kd Taken from the set of prime numbers P, and ensure that the prime number basis vectors B of different threads are... k Not entirely the same; based on the thread-specific prime basis vector B k Initialize a Halton sequence generator whose internal state is determined by the prime number basis vector B. k Uniquely determined; in each sampling of the path planning thread, its dedicated Halton sequence generator is called to sequentially generate a D-dimensional deterministic sampling point q_H that is uniformly distributed within a unit hypercube of [0, 1]^D.

[0067] Based on a benchmark sampling sequence, a deterministic sampling sequence is generated through complementary operations. For example, a predefined or generated benchmark sampling sequence S_base is obtained, defined by its point sequence {u1,u2,...,un} in a unit hypercube [0,1]^D; a D-dimensional complementary vector C=[c1,c2,...,cD] is defined, where each component cd is a predefined constant; for each point u_i=[u_i1,u_i2,...,u_iD] in the benchmark sampling sequence S_base, a deterministic sampling sequence is generated through complementary operations between components. The corresponding points of the new sequence S_new are v_i=[v_i1,v_i2,...,v_iD], where the new component v_id of each dimension is calculated according to the following rules: v_id=(1.0-u_id+c_d)mod1.0; or the equivalent operation v_id=f(u_id,c_d) is used, so that v_id is uniformly distributed in the interval [0,1) and is statistically negatively correlated with u_id; the new sequence S_new composed of all v_i points is used as the generated deterministic sampling sequence.

[0068] By performing a predefined permutation transformation on the prime number basis vectors of the benchmark sampling sequence, a new prime number basis vector is obtained, and a new deterministic sampling sequence is generated based on this vector. For example, a prime number basis vector B_base=[b1,b2,...,b] of dimension D is obtained to generate the benchmark sampling sequence. D]; Perform a reverse ordering operation on the components of the prime number basis vector B_base to obtain a new prime number basis vector B_new=[b D ,b D-1 [,...,b1]; Using the new prime number basis vector B_new obtained after reversing the order, initialize a new Halton sequence generator, call the Halton sequence generator initialized based on B_new, and generate the required deterministic sampling sequence.

[0069] The embodiments of this application generate deterministic sampling sequences for each parallel thread through a variety of simple and efficient methods, ensuring that multiple threads can explore different regions of space simultaneously, improving search efficiency and path diversity, while avoiding complex calculations, making the system lighter and easier to implement.

[0070] Based on the above embodiments, the robot's starting state and target state are determined in the following manner; Receive target pose command; Based on the target pose command and the robot's current pose, the robot's starting state and target state are obtained through inverse kinematics calculations.

[0071] The target pose command is a set of command data specified by the operator to define the final spatial position and orientation that the robot's end effector is expected to achieve. This command contains at least three-dimensional position coordinates and attitude information, and is the starting point and target of the path planning task.

[0072] Listen to and receive target pose commands input by the user through at least one of the following interactive interfaces: receive the target point and pose specified by the user by clicking, dragging or inputting values ​​on the 3D digital twin model; receive real-time spatial pose data sent by a physical probe or handheld device tracked by an optical or electromagnetic positioning system; receive target pose parameters generated after being parsed by a speech recognition or gesture recognition module.

[0073] The received raw instruction data is parsed and converted into a standard pose data structure P_goal containing the target point's three-dimensional coordinates (x, y, z) and target pose (Rx, Ry, Rz) or quaternions (qw, qx, qy, qz). The target pose P_goal is visualized in the digital twin environment, and it is only output as a valid instruction after receiving confirmation signals from the user or the superior system.

[0074] Based on the target pose command and the robot's current pose, the robot's starting state and target state are obtained through inverse kinematics calculations. For example, this can be achieved through the following steps: S1. Determine the robot's current pose as the starting state q_init in the robot's joint space by using the forward kinematics formula (if the current pose is a joint angle) or by directly reading the joint encoder data. S2. For the target pose instruction P_goal, call the inverse kinematics solver to calculate the set of joint angle solutions {q_goal_solution} in the robot configuration space that can achieve the pose. S3. From the solution set {q_goal_solution}, select an optimal solution as the target state q_goal according to the preset optimization criteria. The optimization criteria include at least one of the following: selecting the solution that is closest to the current starting state q_init in terms of Euclidean distance; selecting the solution in which each joint angle is far away from its physical motion limit; selecting the solution that makes the robot configuration far away from the kinematic singularity. S4. In the digital twin environment, verify whether the robot model with q_goal as the joint angle collides with the surrounding environment. If a collision occurs, return to step S3 to reselect a suboptimal solution. If no solution is available, report an error.

[0075] This application's embodiments automatically convert intuitive spatial operation instructions into start and end points of motion that the robot can execute, ensuring that the defined planning tasks are intuitive, accurate, and safe.

[0076] To further explain the robot path planning method provided in this application, please refer to the following embodiments.

[0077] refer to Figure 2 , Figure 2 This is an architecture diagram of the robot path planning system provided in an embodiment of this application. This application provides a robot path planning system applied in intelligent operating rooms and medical equipment. The system includes the following modules: The environment modeling and digital twin module uses 3D cameras to identify and construct an intelligent operating room environment. For fixed medical equipment, it uses feature recognition to determine its type and location. For people and other non-fixed objects in the laboratory, it uses point cloud to construct shapes and determine their locations. Finally, it constructs a complete twin environment that reflects the real scene.

[0078] The collision detection module can perform collision detection calculations between mobile DSA (Digital Subtraction Angiography) and the environment based on the shape and position of all objects in the digital twin environment, and is applied to the planning module.

[0079] The path planning module first performs inverse kinematics calculation based on the initial pose and target pose of the mobile DSA device, and then calls the planning algorithm to plan a feasible path.

[0080] The trajectory generation module sets the maximum speed and maximum acceleration of each joint for the planned path, performs local smoothing on the path, and plans the changes in position, speed, and acceleration of each joint with respect to time.

[0081] refer to Figure 3 , Figure 3 This is the second flowchart illustrating the robot path planning method provided in this application embodiment. This application embodiment provides a robot path planning method, primarily applied to autonomous obstacle avoidance path planning for mobile DSA devices in the medical field, overcoming the shortcomings of existing methods such as poor consistency of planning results and low computational efficiency. This method can be implemented through the following steps: (1) Model the environment using a 3D camera system, identify and construct people, obstacles and other medical-related equipment in the environment, and complete the scene construction in the digital twin system.

[0082] (2) Based on the instructions sent by the doctor, determine the target pose to which the device should move, and perform inverse kinematics calculations based on the current pose to obtain the target position q_goal of each joint.

[0083] (3) Enter the path planning module. First, create several parallel threads based on computer performance. Perform path planning calculations independently in each thread. Different threads use different prime bases to create a five-dimensional Halton sequence array. In order to uniformly cover the search space, a new sequence array can be generated by subtracting the generated array from the five-dimensional array of all 1s and reversing the existing prime base. Next, initialize and create a tree structure T in the thread. Initially, it only contains the current joint angle q_init. Iterate the following steps until the termination condition is met: The Halton array is sampled sequentially to obtain the sampling point q_H. At the same time, a certain probability p is set to directly use the target point q_goal as the sampling point to accelerate convergence.

[0084] In tree T, find the node q_near that is closest to q_H. Generally, Euclidean distance is used. Extend the distance from q_near to q_H by a step size δ to obtain a new node q_new. Call the collision detection module. If q_new interferes with the environment, skip the node. If there is no interference, add q_new to tree T.

[0085] In the path optimization phase, find the set Q_near of all nodes within a radius r centered at q_new in tree T. Calculate the path cost (path length) from q_init through each q_near ∈ Q_near to q_new. Select the q_near node that minimizes the total cost of q_new as its parent node and add it to tree T. Then, perform rewiring optimization. For each node q_near in Q_near, check if reaching q_near through q_new reduces its original cost. If so, update the parent node of q_near to q_new and recursively update the cost of its child nodes.

[0086] The termination condition is as follows: if the distance between q_new and q_goal is less than the convergence precision setting, return tree T and terminate all path planning threads; otherwise, continue iterating.

[0087] (4) Perform backtracking rewiring to optimize the path length. Starting from the target node q_goal, backtrack sequentially to the starting point. For the current node q_current, check its parent node q_parrent and grandparent node q_grandparrent. If there is no collision in the straight path from q_grandparrent to q_current, let q_current recognize q_grandparrent as its parent node, skip q_parrent, and repeat the above process until returning to the starting point q_init. Return the final path and complete the planning.

[0088] To verify the effectiveness of the algorithm, a simulation environment was built in Mujuco, such as... Figure 4 As shown, the scenario includes a mobile DSA device, a hospital bed, and a patient, with several people added as obstacles. The number and position of the people vary in different scenarios. The mobile DSA device is fixed to the ceiling in an inverted manner and has 5 joints, of which joint 1 is a movable guide rail, and joints 2-5 are rotary joints. For comparison, RRT from the open-source Motion Planning Library (OMPL) is also included. The algorithm was implemented, and the SIMPLIFY function was enabled to maximize path optimization. In the simulation, the computation time of the method provided in this application was set within 1000ms, while the computation time of OMPL was set within 1500ms. There were four test scenarios. Tables 1-4 show the planned path lengths in the four test scenarios. The first axis of the DSA device is a translational joint, and the other axes are rotational joints, resulting in inconsistent dimensions and therefore separate results. Due to the algorithm design of the method provided in this application, the consistency of the planned paths in the same scenario is guaranteed. In contrast, the OMPL algorithm, due to its randomness, results in different planning results each time. In the simulation test, the OMPL algorithm was run 10 times in each scenario, and the average value of the results was calculated. According to the results, the path length planned by the method provided in this application is significantly shorter than that planned by OMPL, even with a shorter computation time. Furthermore, in scenario 4, due to the dense arrangement of obstacles, the success rate of the OMPL algorithm was only 40%. In summary, the method provided in this application achieves the goal of consistent planning results and has significant performance improvements in both computational efficiency and planning result quality.

[0089] Table 1 Table 2 Table 3 Table 4 This application's embodiments overcome the problem of poor consistency in planning results in traditional sampling-based path planning algorithms, ensuring consistency of planning results even when the environment remains unchanged. Furthermore, compared to traditional methods, computational efficiency and success rate are significantly improved, and the optimality (path length) of the planning results is also enhanced to some extent.

[0090] The robot path planning device provided in this application is described below. The robot path planning device described below can be referred to in correspondence with the robot path planning method described above.

[0091] refer to Figure 5 The robot path planning device provided in this application includes: The thread startup module 501 is used to start multiple parallel path planning threads during the path planning process of the robot, and to assign different deterministic sampling sequences to each path planning thread; wherein, under the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by the standard pseudo-random number generator. Path search module 502 is used to perform path search based on the deterministic sampling sequence in each path planning thread; The path planning module 503 is used to terminate all path planning threads and perform backtracking optimization on the initial path in response to any path planning thread successfully planning an initial path, so as to obtain the motion path of the robot.

[0092] The robot path planning device provided in this application starts multiple parallel path planning threads during the robot's path planning process and assigns a different deterministic sampling sequence to each thread. Under the same sampling quantity, the uniformity of the distribution of the sampling point set generated by the deterministic sampling sequence in the configuration space is higher than that of the sampling point set generated by a standard pseudo-random number generator. In each path planning thread, path search is performed based on the deterministic sampling sequence. In response to any path planning thread successfully planning an initial path, all path planning threads are terminated, and the initial path is backtracked and optimized to obtain the robot's motion path. This application effectively overcomes the problems of inconsistent results and poor real-time performance of traditional random sampling planning by employing deterministic sampling sequences and multi-threaded parallel search. Through backtracking optimization, path quality is systematically improved while maintaining efficiency. Based on this, consistency of path planning results is achieved without environmental changes, while simultaneously improving the optimality and computational efficiency of the path planning results.

[0093] In one embodiment, the path search module 502 is further configured to: Initialize the tree structure for each path planning thread; the initial node of the tree structure corresponds to the starting state of the robot; In each of the path planning threads, sampling points are generated based on the deterministic sampling sequence; In the tree structure maintained by each path planning thread, find the node closest to the sampling point, and expand new nodes from the nearest node toward the sampling point; If the new node meets the collision-free condition, then the new node is added to the tree structure, and parent node optimization and rewiring operations are performed on the tree structure. Repeat the tree growth and optimization operation based on the deterministic sampling sequence until any of the path planning threads successfully plans the initial path.

[0094] In one embodiment, the path search module 502 is further configured to: Using the new node as the center, search for a set of nodes within a neighborhood of a preset radius; Calculate the first path cost from the initial node to the new node via each neighboring node in the node set, and determine the node with the minimum first path cost as the parent node of the new node; For each of the neighboring nodes, calculate the second path cost to reach the neighboring node through the new node; If the cost of the second path is less than the original cost of the neighboring node, the parent node of the neighboring node is updated to the new node.

[0095] In one embodiment, the path planning module 503 is further configured to: Backtracking is performed from the target node to the initial node along the initial path; the target node is the end node of the initial path, corresponding to the target state of the robot; During the backtracking process, the connection relationships between path nodes are optimized by local rewiring to obtain the robot's motion path.

[0096] In one embodiment, the path planning module 503 is further configured to: During the backtracking process, if the current backtracking node has a grandparent node, a collision-free test is performed between the current backtracking node and the grandparent node. If there is no collision on the straight path from the grandparent node to the current backtracking node, then the parent node of the current backtracking node is updated to the grandparent node, thereby removing the parent node from the initial path.

[0097] In one embodiment, the deterministic sampling sequence is generated based on any of the following methods: Each path planning thread is assigned a different prime number base, and the deterministic sampling sequence is generated based on the prime number base; The deterministic sampling sequence is generated based on the benchmark sampling sequence through complementary operations; The prime number base of the reference sampling sequence is reversed, and the deterministic sampling sequence is generated based on the reversed prime number base.

[0098] In one embodiment, the robot's starting state and target state are determined based on the following method; Receive target pose command; Based on the target pose command and the robot's current pose, the robot's starting state and target state are obtained through inverse kinematics calculations.

[0099] Figure 6 An example is a schematic diagram of the physical structure of an electronic device, such as... Figure 6As shown, the electronic device may include a processor 610, a communications interface 620, a memory 630, and a communication bus 640, wherein the processor 610, communications interface 620, and memory 630 communicate with each other via the communication bus 640. The processor 610 can call logical instructions in the memory 630 to execute the following methods: during the robot's path planning process, multiple parallel path planning threads are started, and a different deterministic sampling sequence is assigned to each path planning thread; wherein, under the same number of samples, the uniformity of the distribution of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the uniformity of the distribution of the sample point set generated by a standard pseudo-random number generator; in each path planning thread, path search is performed based on the deterministic sampling sequence; in response to any path planning thread successfully planning an initial path, all path planning threads are terminated, and the initial path is backtracked and optimized to obtain the robot's motion path.

[0100] Furthermore, the logical instructions in the aforementioned memory 630 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a part 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 this application. 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.

[0101] In another aspect, embodiments of this application also provide a non-transitory computer-readable storage medium storing a computer program thereon. When executed by a processor, the computer program implements the robot path planning method provided in the above embodiments, including, for example, starting multiple parallel path planning threads during the robot's path planning process and assigning different deterministic sampling sequences to each path planning thread; wherein, under the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by a standard pseudo-random number generator; in each path planning thread, performing path search based on the deterministic sampling sequence; in response to any path planning thread successfully planning an initial path, terminating all path planning threads and performing backtracking optimization on the initial path to obtain the robot's motion path.

[0102] On the other hand, this application also provides a computer program product, which includes a computer program that can be stored on a non-transitory computer-readable storage medium. When the computer program is executed by a processor, the computer can execute the robot path planning method provided by the above methods. The method includes: in the process of robot path planning, starting multiple parallel path planning threads and assigning different deterministic sampling sequences to each path planning thread; wherein, under the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by a standard pseudo-random number generator; in each path planning thread, performing path search based on the deterministic sampling sequence; in response to any path planning thread successfully planning an initial path, terminating all path planning threads and backtracking optimization of the initial path to obtain the robot's motion path.

[0103] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0104] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0105] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications 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 this application.

[0106] The above embodiments are for illustrative purposes only and are not intended to limit the scope of this application. Although this application has been described in detail with reference to the embodiments, those skilled in the art should understand that various combinations, modifications, or equivalent substitutions of the technical solutions of this application do not depart from the spirit and scope of the technical solutions of this application and should be covered within the scope of the claims of this application.

Claims

1. A robot path planning method, characterized in that, include: During the robot's path planning process, multiple parallel path planning threads are initiated, and a different deterministic sampling sequence is assigned to each path planning thread; wherein, with the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by the standard pseudo-random number generator. In each of the path planning threads, a path search is performed based on the deterministic sampling sequence; In response to any of the path planning threads successfully planning an initial path, all path planning threads are terminated, and the initial path is backtracked and optimized to obtain the robot's motion path.

2. The robot path planning method according to claim 1, characterized in that, In each of the path planning threads, the path search is performed based on the deterministic sampling sequence, including: Initialize the tree structure for each path planning thread; the initial node of the tree structure corresponds to the starting state of the robot; In each of the path planning threads, sampling points are generated based on the deterministic sampling sequence; In the tree structure maintained by each path planning thread, find the node closest to the sampling point, and expand new nodes from the nearest node toward the sampling point; If the new node meets the collision-free condition, then the new node is added to the tree structure, and parent node optimization and rewiring operations are performed on the tree structure. Repeat the tree growth and optimization operation based on the deterministic sampling sequence until any of the path planning threads successfully plans the initial path.

3. The robot path planning method according to claim 2, characterized in that, The step of performing parent node optimization and rewiring operations on the tree structure includes: Using the new node as the center, search for a set of nodes within a neighborhood of a preset radius; Calculate the first path cost from the initial node to the new node via each neighboring node in the node set, and determine the node with the minimum first path cost as the parent node of the new node; For each of the neighboring nodes, calculate the second path cost to reach the neighboring node through the new node; If the cost of the second path is less than the original cost of the neighboring node, the parent node of the neighboring node is updated to the new node.

4. The robot path planning method according to claim 1, characterized in that, The backtracking optimization of the initial path to obtain the robot's motion path includes: Backtracking is performed from the target node to the initial node along the initial path; the target node is the end node of the initial path, corresponding to the target state of the robot; During the backtracking process, the connection relationships between path nodes are optimized by local rewiring to obtain the robot's motion path.

5. The robot path planning method according to claim 4, characterized in that, During the backtracking process, local rewiring optimization is performed on the connection relationships between path nodes to obtain the robot's motion path, including: During the backtracking process, if the current backtracking node has a grandparent node, a collision-free test is performed between the current backtracking node and the grandparent node. If there is no collision on the straight path from the grandparent node to the current backtracking node, then the parent node of the current backtracking node is updated to the grandparent node, thereby removing the parent node from the initial path.

6. The robot path planning method according to claim 1, characterized in that, The deterministic sampling sequence is generated based on any of the following methods: Each path planning thread is assigned a different prime number base, and the deterministic sampling sequence is generated based on the prime number base; The deterministic sampling sequence is generated based on the benchmark sampling sequence through complementary operations; The prime number base of the reference sampling sequence is reversed, and the deterministic sampling sequence is generated based on the reversed prime number base.

7. The robot path planning method according to claim 1, characterized in that, The robot's starting state and target state are determined based on the following method; Receive target pose command; Based on the target pose command and the robot's current pose, the robot's starting state and target state are obtained through inverse kinematics calculations.

8. A robot path planning device, characterized in that, include: The thread startup module is used to start multiple parallel path planning threads during the robot's path planning process, and to assign different deterministic sampling sequences to each of the path planning threads; wherein, under the same number of samples, the distribution uniformity of the sample point set generated by the deterministic sampling sequence in the configuration space is higher than the distribution uniformity of the sample point set generated by the standard pseudo-random number generator. The path search module is used to perform path search based on the deterministic sampling sequence in each of the path planning threads; The path planning module is used to terminate all path planning threads and backtrack to optimize the initial path in response to any path planning thread successfully planning an initial path, thereby obtaining the motion path of the robot.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the robot path planning method as described in any one of claims 1 to 7.

10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the robot path planning method as described in any one of claims 1 to 7.

Images