A robot walking path generation method based on square graph

Abstract

The present invention provides a robot path generation method based on a square domain graph. First, a grid graph is converted into a grid form background, a square domain graph is constructed based on a concept grid, and a breadth-first strategy is adopted according to the positional relationship between square domains to generate a shortest square domain path from a starting point to an end point, which is composed of continuous rectangular spaces. Then, the square domain path is converted into an optimal stationary point path composed of coordinate points. The square domain path is the shortest connected area from the starting point to the end point. The robot uses the path to have a certain autonomous activity space in the process of efficiently reaching a target point. The robot uses the stationary point path to travel in a straight line between coordinate points, so as to achieve the effect of minimizing the number of turns and the shortest distance.

Description

Technical Field

[0001] The present invention relates to the technical field of robot walking path generation, and in particular to a robot walking path generation method based on a square domain graph. Background Art

[0002] Robot technology research has developed into all walks of life. It has been widely cited in many fields such as industry, medicine and military, involving various disciplines. Intelligent mobile robots perceive the state of the surrounding environment through their own sensors and other devices, and use algorithms to quickly and accurately find a safe, collision-free, optimal or suboptimal path from the starting point to the target point by bypassing all obstacles. The path planning method can be divided into two aspects: global path planning and local path planning according to the degree of work environment information obtained. Local path planning uses sensors to obtain information about the surrounding environment in an unknown environment, so that the robot can obtain a safe path without collision. Global path planning means that the robot has obtained information about the working environment before moving, and finds the optimal path from the starting point to the target point under known environmental information. Both local path planning and global path planning require certain technical methods to automatically generate the robot's walking path. Summary of the invention

[0003] The purpose of the present invention is to provide a path generation method for a robot based on a square graph, and to provide a technical method for generating a robot path.

[0004] The technical solution adopted by the present invention is:

[0005] A robot path generation method based on a square domain graph comprises the following steps:

[0006] Step 1: Enter the robot's starting position P Start 、Target point position P Target and the square domain graph Graph_SF; go to step 2;

[0007] The square domain graph Graph_SF is generated by a domain concept grid with a grid background K=(O, A, I), and each domain concept in the domain concept grid contains its concept square domain set;

[0008] For a grid background K = (O, A, I), the starting position P Start is a two-tuple (x0, y0), where x0 is the object of the grid background, that is, x0∈O; y0 is the attribute of the grid background, that is, y0∈A; similarly, the target point position P Target It is also a two-tuple (x1, y1);

[0009] Step 2: Generate the starting domain concept set CSstart ; Go to step three;

[0010] The starting domain concept set is a square domain including the starting position, called the starting square domain, denoted as SF start ; The domain concept that contains the starting domain is called the starting domain concept, denoted by C start ; The set of all starting domain concepts is referred to as the starting domain concept set, denoted as CS start ;

[0011] Step 3: Initial domain concept set CS start Each starting domain concept C in start The starting area SF start Perform initialization assignment;

[0012] SF start .flag_visit = true;

[0013] SF start .path_cost=0;

[0014] SF start .owner=C start ;

[0015] SF start .pre_node = None;

[0016] And put it into the queue; go to step 4;

[0017] Step 4: If the queue is not empty, go to step 5; otherwise go to step 27;

[0018] Step 5: The first element of the queue is removed from the queue, that is, cur_SF = queue(0), and the process goes to step 6;

[0019] Step 6: If the region cur_SF does not contain the target point position P Target , then go to step seven; otherwise go to step fourteen;

[0020] Step 7, obtain the domain concept cur_C of the square domain cur_SF, that is, cur_C = cur_SF.owner; then, put all direct child concepts Sons (cur_C) and all direct parent concepts Fathers (cur_C) of cur_C into the candidate list candidate_concepts_list, and then go to step 8;

[0021] Step 8: If there is an unprocessed domain concept next_C in the candidate list candidate_concepts_list, go to step 9; otherwise, go to step 4;

[0022] Step 9: If the domain concept next_C has a domain set SFS next_C If there is an unprocessed square field next_SF, go to step 10; otherwise, go to step 8;

[0023] Step 10: If the square domain next_SF is connected and adjacent to the square domain cur_SF, proceed to step 11; otherwise, proceed to step 9;

[0024] The connection between the square domains is: for a grid-shaped background K, (O1, T1) and (O2, T2) are any square domains; if Then the squares (O1, T1) and (O2, T2) are said to be connected, adjacent, and connected, or simply connected and adjacent;

[0025] Step 11: If the square domain has not been visited, that is, next_SF.flag_visit is equal to false, then go to step 12; otherwise, go to step 13;

[0026] Step 12: operate next_SF, that is,

[0027] next_SF.path_cost=cur_SF.path_cost+1;

[0028] next_SF.owner = next_C;

[0029] next_SF.pre_node = cur_SF;

[0030] next_SF.flag_visit = true;

[0031] Then add next_SF to the queue and go to step nine;

[0032] Step 13: If cur_SF.path_cost+1 is less than next_SF.path_cost, set next_SF.pre_node=cur_SF; next_SF.path_cost=cur_SF.path_cost+1; proceed to step 9;

[0033] Step 14: Generate the target point P from the current region cur_SF Target Valid square domain path SF_path, go to step 15;

[0034] The domain path is a sequence composed of path nodes, i.e., SF_path = (N0, N2, …, N n ), where N i = (C i , S i ), 0 ≤ i ≤ n, is a path node, and it satisfies that S i is adjacent to S i+1 , i < n;

[0035] The path node is: for a binary tuple (C, S), where C is a domain concept and S is the domain of the domain concept C, i.e., S ∈ SFS C ;

[0036] Step fifteen, let cur_pos = P start = (x0, y0), the stationary point path enters step sixteen;

[0037] The stationary point path is a sequence composed of the point coordinates of the grid - form background K = (O, A, I), i.e., pos_path = (p0, p2, …, p n ), where the point p i = (x i , y i ), satisfying x i Iy i , x i ∈ O, y i ∈ A; the point p i is the position where the robot stops and adjusts its direction, so p i is called a stationary point;

[0038] Step sixteen, if there is an unprocessed path node (cur_C, cur_SF) in the domain path SF_path, enter step seventeen; otherwise, enter step twenty - four;

[0039] Step seventeen, put the points p in candidate_list that belong to the current domain cur_SF into list, and enter step eighteen;

[0040] Step eighteen, if list is not empty, then let candidate_list = list, enter step sixteen; otherwise enter step nineteen;

[0041] Step nineteen, pre_pos = cur_pos, enter step twenty;

[0042] Step twenty, if candidate_list is not empty, then filter out the points from it according to the Euclidean distance that are close to the target point P TargetThe nearest point cur_pos; go to step 21;

[0043] Step 21, add cur_pos to pos_path, Go to step 22;

[0044] Step 22, if cur_pos.x == pre_pos.x, put the point set {(x1, cur_pos.y)|x1∈cur_SF.O} into candidate_list; go to step 23;

[0045] Step 23, if cur_pos.y == pre_pos.y, put the point set {(cur_pos.x, y1)|y1∈cur_SF.T} into candidate_list; go to step 16;

[0046] Step 24: Filter the distance from the target point P from candidate_list according to the Euclidean distance Target The nearest point cur_pos, go to step 25;

[0047] Step 25, if cur_pos.x == P Target .x or cur_pos.y==P Target .y, add cur_pos to pos_path; otherwise, add the point (cur_pos.x, P Target .y) is added to pos_path; go to step 26;

[0048] Step 26: P Target Add to pos_path and go to step 27;

[0049] Step twenty-seven, end.

[0050] Preferably, in step 1, the step of generating a square domain diagram is:

[0051] 1) Generate a grid background K = (O, A, I) according to the robot's environment; proceed to step 2);

[0052] The grid-like background is a triple K=(O,A,I) where O is a continuous object set, i.e., O={o1,o2,...,o m The subscripts of each object element in} are continuous, indicating the rows of the grid table; A is a continuous attribute set A = {a1, a2, ..., a nThe subscripts of each attribute element in} are continuous, indicating the columns of the grid table; I is the binary relationship between O and A, oIa, o∈O, a∈A if and only if there is no obstacle at row o and column a;

[0053] 2) Generate domain concept grid (CS K ,≤); go to step 3);

[0054] The domain concept grid is a grid-like background K generated by all domain concepts CS K and the partial order relation ≤ on it, forming a complete lattice, denoted as (CS K ,≤);

[0055] The domain concept is that for a grid background K = (O, A, I), And satisfy f(X)=Y,g(Y)=X, the tuple (X,Y) is called a domain concept, where X is the extension of the domain concept and Y is the connotation of the domain concept; CS K is the overall concept of the grid formal background K; where functions f and g are the Galois connections in formal concept analysis;

[0056] The partial order relationship between the domain concepts is: Let (X1, Y1) and (X2, Y2) be any two domain concepts in the grid background K = (O, A, I), then define (X1, Y1) is called the subconcept of (X2, Y2), and (X2, Y2) is the parent concept of (X1, Y1); the ≤ is the set CS K Partial order on ;

[0057] 3) Generate the square domain graph Graph_SF from the domain concept lattice;

[0058] The domain is an arbitrary domain concept where (X, Y) is a grid background K = (O, A, I), where the object set X consists of one or more continuous object sets, that is, X = O1∪O2∪…∪O k , k<‖O‖, and the union of any two continuous object sets is not a continuous object set; the attribute set Y consists of one or more continuous attribute sets, that is, Y=A1∪A2∪…∪A j ,j<‖A‖, and the union of any two continuous attribute sets is not a continuous attribute set; then the tuple (S,T), where S∈{O1,O2,…,O k}, T∈{A1,A2,…,A j}, called a square domain of the domain concept (X, Y);

[0059] The square domain graph Graph_SF is a domain concept grid of a grid background K. Each domain concept (X, Y)∈CS K, all have their own conceptual domain set SFS (X，Y) , that is, Graph_SF=(CS K ,≤,SFS (X，Y) );

[0060] The concept domain set is the set of all domains of a domain concept, expressed as SFS (X，Y) .

[0061] Preferably, in step 2, the step of generating a set of all domain concepts including the starting point P is as follows:

[0062] 1) For a grid background K = (O, A, I), input a point coordinate, expressed as P = (o, a), where oIa, o∈O, a∈A; proceed to step 2);

[0063] 2) According to the formal concept analysis method, the attribute concept and object concept of P = (o, a) are obtained, namely (g(a), f(g(a))), (g(f(o)), f(o)) respectively; proceed to step 3);

[0064] 3) Let Fathers(C0) represent all the parent concepts of domain concept C0, and Sons(C0) represent all the child concepts of domain concept C0, that is:

[0065] Fathers(C0)={C|C∈CS K ,C≥C0} (1)

[0066] Sons(C0)={C|C∈CS K ,C≤C0} (2)

[0067] CS(P)={Fathers((g(f(o)), f(o)))∪{(g(f(o)), f(o))}}∩{Sons((g(a), f(g(a)))∪{(g(a), f(g(a)))}} (3)

[0068] Then, the set of all domain concepts containing point P is obtained by formula (3): Let P be the starting point, that is, P = P start , C.S. start =CS(P Start ), go to step 4);

[0069] 4) End.

[0070] Preferably, in step 14, the current region cur_SF generates the target point P Target The steps of SF_path are as follows:

[0071] 1) Generate a path node (cur_SF.ower, cur_SF), add the path SF_path list header, and go to step 2)

[0072] 2) If cur_SF.pre_node is equal to None, go to step 4); otherwise go to step 3);

[0073] 3) Let cur_SF = cur_SF.pre_node, and go to step 1);

[0074] 4) Return SF_path, ending.

[0075] The beneficial effects produced by the present invention are:

[0076] 1. The present invention can generate an optimal path, which is composed of coordinate points, and the robot can travel in a straight line between the coordinate points.

[0077] 2. The path generated by the present invention can achieve the effect of minimizing the number of turns and the shortest distance for a four-way robot.

[0078] 3. The intermediate result of the present invention, that is, the path composed of continuous rectangular spaces (square domains), is the shortest connected area from the starting point to the end point, which is conducive to the robot having a certain amount of autonomous activity space in the process of efficiently reaching the target point, and is more suitable for use by multi-directional robots such as eight-directional robots. BRIEF DESCRIPTION OF THE DRAWINGS

[0079] Figure 1 is a flow chart of the method of the present invention;

[0080] Figure 2 It is a schematic diagram of the system structure of the present invention;

[0081] Figure 3 is a grid map of the robot's environment;

[0082] Figure 4 The domain concept lattice generated for the grid form background K;

[0083] Figure 5 The optimal path diagram is generated. DETAILED DESCRIPTION

[0084] The present invention will be further described below in conjunction with the accompanying drawings.

[0085] like Figure 1 As shown, the present invention is a robot path generation method based on a square domain graph, comprising the following steps:

[0086] Step 1: Enter the robot's starting position P Start 、Target point position P Targetand the square domain graph Graph_SF; proceed to step 2.

[0087] When generating the square domain graph Graph_SF, the following steps are used:

[0088] 1) Generate a grid background K = (O, A, I) according to the robot's environment; proceed to step 2);

[0089] 2) Generate domain concept grid (CS K ,≤); go to step 3);

[0090] 3) Generate the square domain graph Graph_SF from the domain concept lattice.

[0091] Step 2: Generate the starting domain concept set CS start ; Go to step 3.

[0092] The steps to generate a set of all domain concepts containing the starting point P are as follows:

[0093] 1) For a grid background K = (O, A, I), input a point coordinate, expressed as P = (o, a), where oIa, o∈O, a∈A; proceed to step 2);

[0094] 2) According to the formal concept analysis method, the attribute concept and object concept of P = (o, a) are obtained, namely (g(a), f(g(a))), (g(f(o)), f(o)) respectively; proceed to step 3);

[0095] 3) Let Fathers(C0) represent all the parent concepts of domain concept C0, and Sons(C0) represent all the child concepts of domain concept C0, that is:

[0096] Fathers(C0)={C|C∈CS K ,C≥C0} (1)

[0097] Sons(C0)={C|C∈CS K ,C≤C0} (2)

[0098] CS(P)={Fathers((g(f(o)), f(o)))∪{(g(f(o)), f(o))}}∩{Sons((g(a), f(g(a)))∪{(g(a), f(g(a)))}} (3)

[0099] Then, the set of all domain concepts containing point P is obtained by formula (3): Let P be the starting point, that is, P = P start , C.S. start =CS(P Start ), go to step 4);

[0100] 4) End.

[0101] Step 3: Initial domain concept set CS start Each starting domain concept C in start The starting area SF start Perform initialization assignment;

[0102] SF start .flag_visit = true;

[0103] SF start .path_cost=0;

[0104] SF start .owner=C start ;

[0105] SF start .pre_node = None;

[0106] And put it into the queue; go to step 4.

[0107] Step 4: If the queue is not empty, go to step 5; otherwise go to step 27;

[0108] Step 5: The first element of the queue is removed from the queue, that is, cur_SF = queue(0), and the process goes to step 6;

[0109] Step 6: If the region cur_SF does not contain the target point position P Target , then go to step seven; otherwise, go to step fourteen.

[0110] Step 7, obtain the domain concept cur_C of the square domain cur_SF, that is, cur_C = cur_SF.owner; then, put all direct child concepts Sons (cur_C) and all direct parent concepts Fathers (cur_C) of cur_C into the candidate list candidate_concepts_list, and then go to step 8.

[0111] Step 8: If there is an unprocessed domain concept next_C in the candidate list candidate_concepts_list, go to step 9; otherwise, go to step 4.

[0112] Step 9: If the domain concept next_C has a domain set SFS next_C If there is an unprocessed square field next_SF, go to step ten; otherwise, go to step eight.

[0113] Step 10: If the square domain next_SF is connected and adjacent to the square domain cur_SF, proceed to step 11; otherwise, proceed to step 9.

[0114] Step 11: If the square domain has not been visited, that is, next_SF.flag_visit is equal to false, then go to step 12; otherwise, go to step 13.

[0115] Step 12: operate next_SF, that is,

[0116] next_SF.path_cost=cur_SF.path_cost+1;

[0117] next_SF.owner = next_C;

[0118] next_SF.pre_node = cur_SF;

[0119] next_SF.flag_visit = true;

[0120] Then add next_SF to the queue and go to step nine.

[0121] Step 13: If cur_SF.path_cost+1 is less than next_SF.path_cost, set next_SF.pre_node=cur_SF; next_SF.path_cost=cur_SF.path_cost+1; and proceed to step 9.

[0122] Step 14: Generate the target point P from the current region cur_SF Target Valid square domain path SF_path, go to step fifteen.

[0123] The target point P is generated by the current area cur_SF Target The steps of SF_path are as follows:

[0124] 1) Generate a path node (cur_SF.ower, cur_SF), add the path SF_path list header, and go to step 2)

[0125] 2) If cur_SF.pre_node is equal to None, go to step 4); otherwise go to step 3);

[0126] 3) Let cur_SF = cur_SF.pre_node, and go to step 1);

[0127] 4) Return SF_path, ending.

[0128] Step 15, let cur_pos = P start =(x0, y0), stationary point path Go to step 16;

[0129] Step 16: If there are unprocessed path nodes (cur_C, cur_SF) in the square domain path SF_path, proceed to step 17; otherwise, proceed to step 24;

[0130] Step 17: put the point p in candidate_list that belongs to the current square region cur_SF into the list, and go to step 18;

[0131] Step 18, if list is not empty, set candidate_list = list, Go to step 16; otherwise go to step 19;

[0132] Step 19, pre_pos=cur_pos, proceed to step 20;

[0133] Step 20: If candidate_list is not empty, select the candidate point P from the candidate list based on the Euclidean distance. Target The nearest point cur_pos; go to step 21;

[0134] Step 21, add cur_pos to pos_path, Go to step 22;

[0135] Step 22, if cur_pos.x == pre_pos.x, put the point set {(x1, cur_pos.y)|x1∈cur_SF.O} into candidate_list; go to step 23;

[0136] Step 23, if cur_pos.y == pre_pos.y, put the point set {(cur_pos.x, y1)|y1∈cur_SF.T} into candidate_list; go to step 16;

[0137] Step 24: Filter the distance from the target point P from candidate_list according to the Euclidean distance Target The nearest point cur_pos, go to step 25;

[0138] Step 25, if cur_pos.x == P Target .x or cur_pos.y==P Target.y, add cur_pos to pos_path; otherwise, add the point (cur_pos.x, P Target .y) is added to pos_path; go to step 26;

[0139] Step 26: P Target Add to pos_path and go to step 27;

[0140] Step twenty-seven, end.

[0141] like Figure 2 As shown, the present invention includes two main modules: an optimal square path generation module and a stationary path generation module.

[0142] The optimal square domain path generation module is responsible for generating the optimal square domain path from the square domain graph; the stationary point path generation module is responsible for converting the square domain path into the coordinate stationary point path required for the robot to walk.

[0143] The present invention provides path information for the robot walking module; at the same time, other modules are responsible for providing corresponding services. For example, the environment data generation module is responsible for converting the robot's environment into a corresponding grid-form background; the domain concept grid generation module converts the grid-form background into a grid concept grid; the square domain map generation module is responsible for generating a square domain map from the grid concept grid for use by the robot path generation module.

[0144] Embodiment 1:

[0145] like Figure 3 As shown in the figure, the robot's environment can be transformed into a grid map. The blank part is the obstacle-free area, and the robot can walk freely. The starting point is the square where the hollow circle is located, and the end point is the square where the solid circle is located.

[0146] According to the method of the present invention, a square path and a stationary path from the starting point to the end point are generated. The robot travels along the square path and only needs to stop at the stationary point and adjust the direction, so as to achieve the effect of minimizing the number of turns and the shortest distance.

[0147] First, according to step 1, input the robot's starting position P Start =(0,0) and the target point position P Target =(5,5), and the square domain graph Graph_SF. The square domain graph Graph_SF is derived from the grid background generated according to the robot's environment, as shown in Table 1; the structure between the nodes of the square domain graph Graph_SF is as follows Figure 4 As shown in Table 2, each domain concept node has its own square domain set.

[0148] Table 1 Grid form background K

[0149] 1 1 1 0 0 0 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 1 0 1 0 1 1 1 1 1 1 1

[0150] Table 2 Each node of the square domain graph Graph_SF

[0151]

[0152]

[0153]

[0154] Step 2: Generate the starting domain concept set CS start , generated from the starting domain concept set CS from the square domain graph Graph_SF start (Using the ID value of the domain concept): Starting domain concept set CS start : {0, 9, 10, 2}.

[0155] Step 3: Initial domain concept set CS start = Each starting domain concept C in {0, 9, 10, 2} start The starting area SF start Perform initialization assignment; for example: the starting domain of the domain concept with ID = 0 is the domain SF with id = 0 in its domain set id＝0 , order: SF id＝0 .flag_visit = true; SF id＝0 .path_cost=0; SF id＝0 .owner=C start SF id＝ 0. pre_node = None, and put it into the queue queue; and so on, after processing the starting domain concept set CS start =For each starting domain concept in {0, 9, 10, 2}, go to step 4.

[0156] According to step 4, because the queue is not empty, go to step 5.

[0157] Step 5: The first element of the queue queue is dequeued, that is, cur_SF is the square domain with id=0 in the domain concept with ID=0, and the process goes to step 6.

[0158] According to step 6, the region cur_SF does not contain the target point position P Target , go to step seven.

[0159] According to step 7, the domain concept cur_C of the square domain cur_SF is obtained, that is, cur_C = SF start.owner is the domain concept with ID=0; then all its direct child concepts and all its direct parent concepts are put into the candidate list candidate_concepts_list, that is, candidate_concepts_list=[2,10,5]. Then go to step 8, get the domain concept next_C from the candidate list candidate_concepts_list as the square domain with ID=2; then go to step 9.

[0160] According to step nine, step ten, step eleven, step twelve and step thirteen, traverse the domain set of the domain ID = 2 to determine whether it is a domain adjacent to cur_SF, that is, the domain ID = 0. It can be obtained that the domains of id = 0 and id = 1 in the domain set of ID = 2 are adjacent to it, and the domain of id = 0 has been added to the queue in step three, while id = 1 has not been added. Therefore, let the domain of id = 1 be next_SF, and let next_SF.path_cost = cur_SF.path_cost+1; next_SF.owner = next_C; next_SF.pre_node = cur_SF; next_SF.flag_visit = true, and add it to the queue. Continue to traverse the domain set of the domain concepts of ID = 10 and ID = 5 in this way, and add them to the queue, and enter step four. And so on, enter step fourteen.

[0161] Step 14: Generate the target point P from the current region cur_SF Target The effective path is obtained to obtain the optimal square path SF_path = ((9,0), (2,2), (0,2), (5,2), (1,0)). Go to step 15.

[0162] Step 15, let cur_pos = P Start =(x0,y0), stationary point path Go to step sixteen.

[0163] According to step 16, there are unprocessed path nodes in the square domain path SF_path, which are processed in sequence, and (9,0) is taken, and step 17 is entered; therefore, at this time and Go to step 19, pre_pos = cur_pos, then go to step 21; add cur_pos to pos_path, Go to step twenty-two.

[0164] Step 22, because cur_pos.x == pre_pos.x, put the point set {(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0)} into candidate_list; go to step 23.

[0165] Step 23: because cur_pos.y == pre_pos.y, put the point set {(0,0)} into candidate_list. Go to step 16; and so on, traverse all the path nodes in the square path SF_path, at this time pos_path = ((0,0)); candidate_list = ((5,0)); go to step 24, cur_pos = (5,0); go to step 25, add cur_pos to pos_path; go to step 26.

[0166] Step 24: Filter the distance from the target point P from candidate_list according to the Euclidean distance Target The nearest point cur_pos, go to step 25, and change P Target Add to pos_path. Finally, we get the stationary path pos_path = ((0,0), (5,0), (5,5)).

[0167] If the robot moves in a straight line according to the coordinates given by the stationary path pos_path = ((0,0), (5,0), (5,5)), it only needs one turn to reach the target point; the path is as follows Figure 5 As shown, the black straight line is the path of traveling along the coordinate straight line.

[0168] If the robot moves freely in the set area according to the intermediate result, that is, the square path SF_path = ((9,0), (2,2), (0,2), (5,2), (1,0)), the path is as follows Figure 5 As shown, the light grey part represents the path of the domain, and the area passed through is also the shortest among all routes.

Claims

1. A robot path generation method based on a square graph, characterized in that: The steps include: Step 1: Enter the robot's starting position P Start 、Target point position P Target and the square domain graph Graph_SF; go to step 2; The steps of generating the square domain diagram are: 1) Generate a grid background K = (O, A, I) according to the robot's environment; proceed to step 2); The grid-like background is a triple K=(O,A,I) where O is a continuous object set, i.e., O={o1,o2,...,o m The subscripts of each object element in} are continuous, indicating the rows of the grid table; A is a continuous attribute set A = {a1, a2, ..., a n The subscripts of each attribute element in} are continuous, indicating the columns of the grid table; I is the binary relationship between O and A, oIa, o∈O, a∈A if and only if there is no obstacle at row o and column a; 2) Generate domain concept grid (CS K ,≤); go to step 3); The domain concept grid is a grid-like background K generated by all domain concepts CS K and the partial order relation ≤ on it, forming a complete lattice, denoted as (CS K ,≤); The domain concept is a grid-like background And satisfy f(X)=Y,g(Y)=X, the tuple (X,Y) is called a domain concept, where X is the extension of the domain concept and Y is the connotation of the domain concept; CS K is the overall concept of the grid formal background K; where functions f and g are the Galois connections in formal concept analysis; The partial order relationship between the domain concepts is: Let (X1, Y1) and (X2, Y2) be any two domain concepts in the grid background K = (O, A, I), then define (X1, Y1) is called the subconcept of (X2, Y2), and (X2, Y2) is the parent concept of (X1, Y1); the ≤ is the set CS K Partial order on ; 3) Generate the square domain graph Graph_SF from the domain concept lattice; The domain is an arbitrary domain concept where (X, Y) is a grid background K = (O, A, I), where the object set X consists of one or more continuous object sets, that is, X = O1∪O2∪…∪O k , k<||O||, and the union of any two continuous object sets is not a continuous object set; the attribute set Y consists of one or more continuous attribute sets, that is, Y=A1∪A2∪…∪A j , j < ||A||, and the union of any two continuous attribute sets is not a continuous attribute set; then the tuple (S, T), where S∈{O1,O2,…,O k }, T∈{A1,A2,…,A j }, called a square domain of the domain concept (X, Y); The square domain graph Graph_SF is a domain concept grid of a grid background K. Each domain concept (X, Y)∈CS K , all have their own conceptual domain set SFS (X，Y) , that is, Graph_SF=(CS K ,≤,SFS (X，Y) ); The concept domain set is the set of all domains of a domain concept, expressed as SFS (X，Y) ; Step 2: Generate the starting domain concept set CS start ; Go to step three; The steps to generate a set of all domain concepts containing the starting point P are as follows: 1) For a grid background K = (O, A, I), input a point coordinate, expressed as P = (o, a), where oIa, o∈O, a∈A; proceed to step 2); 2) According to the formal concept analysis method, the attribute concept and object concept of P = (o, a) are obtained, namely (g(a), f(g(a))), (g(f(o)), f(o)) respectively; proceed to step 3); 3) Let Fathers(C0) represent all the parent concepts of domain concept C0, and Sons(C0) represent all the child concepts of domain concept C0, that is: Fathers(C0)={C|C∈CS K ,C≥C0} (1) Sons(C0)={C|C∈CS K ,C≤C0} (2) CS(P)={Fathers((g(f(o)), f(o)))∪{(g(f(o)), f(o))}}∩{Sons((g(a), f(g(a)))∪{(g(a), f(g(a)))}} (3) Then, the set of all domain concepts containing point P is obtained by formula (3): Let P be the starting point, that is, P = P start , C.S. start =CS(P Start ), go to step 4); 4) End; Step 3: Initial domain concept set CS start Each starting domain concept C in start The starting area SF start Perform initialization assignment; SF start .flag_visit = true; SF start .path_cost=0; SF start .owner=C start ; SF start .pre_node=None; And put it into the queue; go to step 4; Step 4: If the queue is not empty, go to step 5; otherwise go to step 27; Step 5: The first element of the queue is removed from the queue, that is, cur_SF = queue(0), and the process goes to step 6; Step 6: If the region cur_SF does not contain the target point position P Target , then go to step seven; otherwise go to step fourteen; Step 7, obtain the domain concept cur_C of the square domain cur_SF, that is, cur_C = cur_SF.owner; then, put all direct child concepts Sons (cur_C) and all direct parent concepts Fathers (cur_C) of cur_C into the candidate list candidate_concepts_list, and then go to step 8; Step 8: If there is an unprocessed domain concept next_C in the candidate list candidate_concepts_list, go to step 9; otherwise, go to step 4; Step 9: If the domain concept next_C has a domain set SFS next_C If there is an unprocessed square field next_SF, go to step 10; otherwise, go to step 8; Step 10: If the square domain next_SF is connected and adjacent to the square domain cur_SF, proceed to step 11; otherwise, proceed to step 9; The connection between the square domains is: for a grid-shaped background K, (O1, T1) and (O2, T2) are any square domains; if Then the squares (O1, T1) and (O2, T2) are said to be connected, adjacent, and connected, or simply connected and adjacent; Step 11: If the square domain has not been visited, that is, next_SF.flag_visit is equal to false, then go to step 12; otherwise, go to step 13; Step 12: operate next_SF, that is, next_SF.path_cost=cur_SF.path_cost+1; next_SF.owner = next_C; next_SF.pre_node = cur_SF; next_SF.flag_visit = true; Then add next_SF to the queue and go to step nine; Step 13: If cur_SF.path_cost+1 is less than next_SF.path_cost, set next_SF.pre_node=cur_SF; next_SF.path_cost=cur_SF.path_cost+1; proceed to step 9; Step 14: Generate the target point P from the current region cur_SF Target Valid square domain path SF_path, go to step 15; The target point P is generated by the current area cur_SF Target The steps of SF_path are as follows: 1) Generate a path node (cur_SF.ower, cur_SF), add the path SF_path list header, and go to step 2) 2) If cur_SF.pre_node is equal to None, go to step 4); otherwise go to step 3); 3) Let cur_SF = cur_SF.pre_node, and go to step 1); 4) Return SF_path, end; Step 15, let cur_pos = P start =(x0, y0), stationary point path Go to step 16; The stationary point path is a sequence of point coordinates of a grid background K = (O, A, I), that is, pos_path = (p0, p2, ..., p n ), where point p i =(x i ,y i ), satisfying x i I i , x i ∈O,y i ∈A; the point p i It is the position where the robot stops and adjusts its direction, so it is called p i For stationing point; Step 16: If there are unprocessed path nodes (cur_C, cur_SF) in the square domain path SF_path, proceed to step 17; otherwise, proceed to step 24; Step 17: put the point p in candidate_list that belongs to the current square region cur_SF into the list, and go to step 18; Step 18, if list is not empty, set candidate_list = list, Go to step 16; otherwise go to step 19; Step 19, pre_pos=cur_pos, proceed to step 20; Step 20: If candidate_list is not empty, select the candidate point P from the candidate list based on the Euclidean distance. Target The nearest point cur_pos; go to step 21; Step 21, add cur_pos to pos_path, Go to step 22; Step 22, if cur_pos.x == pre_pos.x, put the point set {(x1, cur_pos.y)|x1∈cur_SF.O} into candidate_list; go to step 23; Step 23, if cur_pos.y == pre_pos.y, put the point set {(cur_pos.x, y1)|y1∈cur_SF.T} into candidate_list; go to step 16; Step 24: Filter the distance from the target point P from candidate_list according to the Euclidean distance Target The nearest point cur_pos, go to step 25; Step 25, if cur_pos.x == P Target .x or cur_pos.y==P Target .y, add cur_pos to pos_path; otherwise, add the point (cur_pos.x, P Target .y) is added to pos_path; go to step 26; Step 26: P Target Add to pos_path and go to step 27; Step twenty-seven, end.

Images