devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

常用路径规划算法

作者：笔触狂放9 | 2024-05-25 20:17:39

赞

踩

常用路径规划算法

很全的资料（ROS实现）：GitHub - ai-winter/ros_motion_planning: Motion planning and Navigation of AGV/AMR：ROS planner plugin implementation of A*, JPS, D*, LPA*, D* Lite, Theta*, RRT, RRT*, RRT-Connect, Informed RRT*, ACO, PSO, Voronoi, PID, DWA, APF etc.

 大佬博主博客：图解自动驾驶中的运动规划(Motion Planning)，附几十种规划算法_自动驾驶驾驶动态规划算法-CSDN博客

一、基于图搜索的global planner

1、Dijkstra

参考文献：

[1]https://ieeexplore.ieee.org/document/736775

[2]https://ieeexplore.ieee.org/document/1690266

原文链接：Dijkstra算法图文详解-CSDN博客

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<iostream>
  5. #define Inf 0x3f3f3f3f
  6.  
  7. using namespace std;
  8.  
  9. int map[1005][1005];
  10.  
  11. int vis[1005], dis[1005];
  12. int n, m;
  13. void Init()
  14. {
  15. 	memset(map, Inf, sizeof(map));
  16. 	for (int i = 1; i <= n; i++)
  17. 	{
  18. 		map[i][i] = 0;
  19. 	}
  20. }
  21.  
  22. void Getmap()
  23. {
  24. 	int u, v, w;
  25. 	for (int t = 1; t <= m; t++)
  26. 	{
  27. 		scanf_s("%d%d%d", &u, &v, &w);
  28. 		if (map[u][v] > w)
  29. 		{
  30. 			map[u][v] = w;
  31. 			map[v][u] = w;
  32. 		}
  33. 	}
  34.  
  35. }
  36.  
  37. void Dijkstra(int u)
  38. {
  39. 	memset(vis, 0, sizeof(vis));
  40. 	for (int t = 1; t <= n; t++)
  41. 	{
  42. 		dis[t] = map[u][t];
  43. 	}
  44. 	vis[u] = 1;
  45. 	for (int t = 1; t < n; t++)
  46. 	{
  47. 		int minn = Inf, temp;
  48. 		for (int i = 1; i <= n; i++)
  49. 		{
  50. 			if (!vis[i] && dis[i] < minn)
  51. 			{
  52. 				minn = dis[i];
  53. 				temp = i;
  54. 			}
  55. 		}
  56. 		vis[temp] = 1;
  57. 		for (int i = 1; i <= n; i++)
  58. 		{
  59. 			if (map[temp][i] + dis[temp] < dis[i])
  60. 			{
  61. 				dis[i] = map[temp][i] + dis[temp];
  62. 			}
  63. 		}
  64. 	}
  65.  
  66. }
  67.  
  68. int main()
  69. {
  70.     /*
  71. 	input；
  72. 	5 4
  73. 1 2 3
  74. 2 3 4
  75. 3 4 1
  76. 4 1 8
  77. 2 4 2*/
  78. 	scanf_s("%d%d", &m, &n);//5,4
  79. 	Init();
  80. 	Getmap();
  81. 	Dijkstra(n);//4
  82. 	printf("%d\n", dis[1]);
  83.  
  84.  
  85. 	return 0;
  86. }

 

2、A* 家族

2.1A* 

参考文献：[1]https://www.roboticsproceedings.org/rss04/p28.pdf

  1. #include <stdio.h>
  2. #include <vector>
  3. using namespace std;
  4. #define ROWS  10
  5. #define COLS  10
  6.  
  7. #define ZXDJ 10
  8. #define XXDJ 14
  9.  
  10. enum direct { p_up, p_down, p_left, p_right, p_lup, p_ldown, p_rup, p_rdown };
  11.  
  12. struct MyPoint {
  13. 	int  row;		//y
  14. 	int  col;		//x
  15. 	int  f, g, h;	//用来量化评估的
  16.  
  17. 	void getF() { f = g + h; }
  18. };
  19.  
  20. //树节点
  21. struct treeNode {
  22. 	MyPoint				pos;
  23. 	treeNode* pParent;
  24. 	vector<treeNode*>	child;
  25. };
  26.  
  27. treeNode* createNode(MyPoint pos) {
  28. 	treeNode* pNew = new  treeNode;
  29. 	//memset(pNew, 0, sizeof treeNode);//清空
  30. 	*pNew = { 0 };
  31. 	pNew->pos.row = pos.row;
  32. 	pNew->pos.col = pos.col;
  33. 	return pNew;
  34. }
  35.  
  36. int getH(MyPoint pos, MyPoint endPos);
  37.  
  38. int main() {
  39. 	//描述地图
  40. 	int map[ROWS][COLS] = {
  41. 		{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  42. 		{ 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
  43. 		{ 0, 1, 0, 1, 1, 0, 0, 0, 0, 0 },
  44. 		{ 0, 1, 1, 0, 1, 0, 0, 0, 0, 0 },
  45. 		{ 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
  46. 		{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  47. 		{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  48. 		{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  49. 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  50. 		{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }
  51. 	};
  52. 	bool pathMap[ROWS][COLS] = { 0 };//全部都是false 没有走过
  53. 	//起点和终点
  54. 	MyPoint begPos = { 1, 1 };
  55. 	MyPoint endPos = { 6, 7 };
  56.  
  57. 	pathMap[begPos.row][begPos.col] = true;//起点标记走过
  58. 	treeNode* pRoot = createNode(begPos);//起点成为树根
  59.  
  60. 	//准备一个数组用来存储并获取f最小的点
  61. 	vector<treeNode*> buff;
  62.  
  63. 	vector<treeNode*>::iterator it;
  64. 	vector<treeNode*>::iterator itMin;
  65.  
  66. 	treeNode* pCurrent = pRoot;//当前点
  67. 	bool isFindEnd = false;
  68.  
  69.  
  70.  
  71. 	//寻路
  72. 	while (1) {
  73. 		//当前点发散出8个点
  74. 		for (int i = 0; i < 8; i++) {
  75. 			treeNode* pTemp = createNode(pCurrent->pos);
  76. 			switch (i)
  77. 			{
  78. 			case p_up:
  79. 				pTemp->pos.row--;
  80. 				pTemp->pos.g += ZXDJ;
  81. 				break;
  82. 			case p_down:
  83. 				pTemp->pos.row++;
  84. 				pTemp->pos.g += ZXDJ;
  85. 				break;
  86. 			case p_left:
  87. 				pTemp->pos.col--;
  88. 				pTemp->pos.g += ZXDJ;
  89. 				break;
  90. 			case p_right:
  91. 				pTemp->pos.col++;
  92. 				pTemp->pos.g += ZXDJ;
  93. 				break;
  94. 			case p_lup:
  95. 				pTemp->pos.row--;
  96. 				pTemp->pos.col--;
  97. 				pTemp->pos.g += XXDJ;
  98. 				break;
  99. 			case p_ldown:
  100. 				pTemp->pos.row++;
  101. 				pTemp->pos.col--;
  102. 				pTemp->pos.g += XXDJ;
  103. 				break;
  104. 			case p_rup:
  105. 				pTemp->pos.row--;
  106. 				pTemp->pos.col++;
  107. 				pTemp->pos.g += XXDJ;
  108. 				break;
  109. 			case p_rdown:
  110. 				pTemp->pos.row++;
  111. 				pTemp->pos.col++;
  112. 				pTemp->pos.g += XXDJ;
  113. 				break;
  114. 			}//end of switch
  115. 			//能走的才考虑  已经走过的应该不考虑
  116. 			if (pathMap[pTemp->pos.row][pTemp->pos.col] == false &&
  117. 				map[pTemp->pos.row][pTemp->pos.col] == 0 &&
  118. 				pTemp->pos.row >= 0 && pTemp->pos.row < ROWS &&
  119. 				pTemp->pos.col >= 0 && pTemp->pos.col < COLS) {
  120. 				//计算h值
  121. 				pTemp->pos.h = getH(pTemp->pos, endPos);
  122. 				//计算f值
  123. 				pTemp->pos.getF();
  124. 				//入树
  125. 				pCurrent->child.push_back(pTemp);
  126. 				pTemp->pParent = pCurrent;
  127. 				//数组存储
  128. 				buff.push_back(pTemp);
  129. 			}
  130. 			else {//不能走
  131. 				//delete pTemp;//释放pTemp
  132. 			}
  133. 		}//end of for
  134. 		//找出buff中 f最小的节点
  135. 		itMin = buff.begin();//假设第一个的f值最小
  136. 		//从第一个找到最后一个
  137. 		for (it = buff.begin(); it != buff.end(); it++) {
  138. 			itMin = (((*itMin)->pos.f < (*it)->pos.f) ? itMin : it);
  139. 		}
  140. 		//pCurrent指向它
  141. 		pCurrent = *itMin;
  142. 		pathMap[pCurrent->pos.row][pCurrent->pos.col] = true;//标记走过
  143. 		printf("current(%d,%d)\n", pCurrent->pos.row, pCurrent->pos.col);
  144. 		//buff中删掉它
  145. 		buff.erase(itMin);
  146. 		//是否到达终点
  147. 		if (pCurrent->pos.row == endPos.row &&
  148. 			pCurrent->pos.col == endPos.col) {
  149. 			isFindEnd = true;
  150. 			break;
  151. 		}
  152. 		//是否buff空了
  153. 		if (buff.size() == 0) break;
  154. 	}//end of while
  155.  
  156. 	if (isFindEnd) {
  157. 		printf("找到终点了!\n");
  158. 		while (pCurrent) {
  159. 			printf("(%d,%d)", pCurrent->pos.row, pCurrent->pos.col);
  160. 			pCurrent = pCurrent->pParent;
  161. 		}
  162. 		printf("\n");
  163. 	}
  164.  
  165. 	while (1);
  166. 	return 0;
  167. }
  168.  
  169. int getH(MyPoint pos, MyPoint endPos) {
  170. 	int x = ((pos.col > endPos.col) ? (pos.col - endPos.col) : (endPos.col - pos.col));
  171. 	int y = ((pos.row > endPos.row) ? (pos.row - endPos.row) : (endPos.row - pos.row));
  172.  
  173. 	return (x + y) * ZXDJ;
  174. }

 

2.2动态A*(D*)

参考文献：https://ieeexplore.ieee.org/document/351061

  1. #pragma once
  2. #include<vector>
  3. #include<queue>
  4. #include<memory>
  5. #include<algorithm>
  6. #include<iostream>
  7. namespace DStar {
  8.     enum State
  9.     {
  10.         New,
  11.         Open,
  12.         Closed
  13.     };
  14.     struct DNode {
  15.         explicit DNode(int X, int Y, DNode* Next = nullptr) : x(X), y(Y), next(Next) {}
  16.         DNode() = default;
  17.         void setObstacle()
  18.         {
  19.             is_obstacle = true;
  20.         }
  21.         int x = 0;
  22.         int y = 0;
  23.         int H = 0; // distance to target
  24.         int K = 0; //所有时刻最小的H！
  25.         State state = New;
  26.         DNode* next = nullptr;
  27.         bool is_obstacle = false;
  28.     };
  29.     struct MyCompare
  30.     {
  31.         bool operator()(DNode* lhs, DNode* rhs) const {
  32.             return lhs->K > rhs->K;
  33.         }
  34.     };
  35.     class DStar {
  36.     public:
  37.         DStar(const std::vector<std::vector<int>> map) : Map(map), shortestPaths(map.size(), std::vector<DNode*>(map.front().size(), nullptr)) {}
  38.         void find_first_path(const std::pair<int, int>& start, const std::pair<int, int>& target, const std::vector<std::pair<int, int>>& obstacles);
  39.         ~DStar()
  40.         {
  41.             for (int i = 0; i < shortestPaths.size(); ++i)
  42.             {
  43.                 for (int j = 0; j < shortestPaths.front().size(); ++j)
  44.                 {
  45.                     if (shortestPaths[i][j])
  46.                         delete shortestPaths[i][j];
  47.                 }
  48.             }
  49.         }
  50.     private:
  51.         int cost(DNode* lhs, DNode* rhs) const;
  52.         void insert(DNode* node, int Cost);
  53.         //核心函数
  54.         int process_state();
  55.         int modify(DNode* node);
  56.         void setObstacles(const std::vector<std::pair<int, int>>& obstacles);
  57.  
  58.     private:
  59.         const static int _cost_low = 10;
  60.         const static int _cost_high = 14;
  61.         const static int _cost_max = 65536;
  62.         std::priority_queue<DNode*, std::vector<DNode*>, MyCompare> openlist;
  63.         std::vector<std::vector<int>> Map;
  64.         std::vector<std::vector<DNode*>> shortestPaths; //保存每个节点到终点的最短路径信息
  65.     };
  66.     int DStar::cost(DNode* lhs, DNode* rhs) const
  67.     {
  68.         if (lhs->is_obstacle || rhs->is_obstacle)
  69.             return _cost_max;
  70.         if (lhs->x != rhs->x && lhs->y != rhs->y)
  71.             return _cost_high;
  72.         else
  73.             return _cost_low;
  74.     }
  75.     void DStar::insert(DNode* node, int new_H)
  76.     {
  77.         new_H = (new_H >= _cost_max) ? _cost_max : new_H;
  78.         if (node->state == New)
  79.         {
  80.             node->H = new_H;
  81.             node->K = new_H;
  82.             node->state = Open;
  83.             shortestPaths[node->x][node->y] = node;
  84.             openlist.push(node);
  85.         }
  86.         else if (node->state == Open) //节点已经在openlist中 那么只需要改变对应openlist位置的节点的H和K即可
  87.         {
  88.  
  89.             node->H = new_H;
  90.             node->K = std::min(node->K, new_H);
  91.         }
  92.         else
  93.         {
  94.             node->K = std::min(node->H, new_H);
  95.             node->H = new_H;
  96.             node->state = Open;
  97.             openlist.push(node);
  98.         }
  99.     }
  100.     int DStar::process_state()
  101.     {
  102.         DNode* cur_min = openlist.top();
  103.         if (!cur_min)
  104.             return -1;
  105.         openlist.pop();
  106.         cur_min->state = Closed;
  107.         int K_old = cur_min->K;
  108.         if (K_old < cur_min->H)
  109.         {
  110.             for (int i = cur_min->x - 1; i <= cur_min->x + 1; ++i)
  111.             {
  112.                 for (int j = cur_min->y - 1; j <= cur_min->y + 1; ++j)
  113.                 {
  114.                     if (i >= 0 && j >= 0 && i < Map.size() && j < Map.front().size() && shortestPaths[i][j])
  115.                     {
  116.                         if (i == cur_min->x && j == cur_min->y)
  117.                             continue;
  118.                         if (shortestPaths[i][j]->H <= K_old && cur_min->H > shortestPaths[i][j]->H + cost(cur_min, shortestPaths[i][j]))
  119.                         {
  120.                             cur_min->H = shortestPaths[i][j]->H + cost(cur_min, shortestPaths[i][j]);
  121.                             cur_min->next = shortestPaths[i][j];
  122.                         }
  123.                     }
  124.                 }
  125.             }
  126.         }
  127.         if (K_old == cur_min->H)
  128.         {
  129.             for (int i = cur_min->x - 1; i <= cur_min->x + 1; ++i)
  130.             {
  131.                 for (int j = cur_min->y - 1; j <= cur_min->y + 1; ++j)
  132.                 {
  133.                     if (i >= 0 && j >= 0 && i < Map.size() && j < Map.front().size())
  134.                     {
  135.                         if (i == cur_min->x && j == cur_min->y)
  136.                             continue;
  137.                         if (!shortestPaths[i][j] && !Map[i][j]) //表示当前节点为New
  138.                         {
  139.                             DNode* neighbor = new DNode(i, j, cur_min);
  140.                             insert(neighbor, cur_min->H + cost(neighbor, cur_min));
  141.                         }
  142.                         else if (shortestPaths[i][j] && !shortestPaths[i][j]->is_obstacle)
  143.                         {
  144.                             if ((shortestPaths[i][j]->next == cur_min && shortestPaths[i][j]->H != cur_min->H + cost(shortestPaths[i][j], cur_min))
  145.                                 || (shortestPaths[i][j]->next != cur_min && shortestPaths[i][j]->H > cur_min->H + cost(shortestPaths[i][j], cur_min)))
  146.                             {
  147.                                 insert(shortestPaths[i][j], cur_min->H + cost(shortestPaths[i][j], cur_min));
  148.                                 shortestPaths[i][j]->next = cur_min;
  149.                             }
  150.                         }
  151.                     }
  152.                 }
  153.             }
  154.         }
  155.         else
  156.         {
  157.             //传递raise状态
  158.             for (int i = cur_min->x - 1; i <= cur_min->x + 1; ++i)
  159.             {
  160.                 for (int j = cur_min->y - 1; j <= cur_min->y + 1; ++j)
  161.                 {
  162.                     if (i == cur_min->x && j == cur_min->y)
  163.                         continue;
  164.                     if (i >= 0 && j >= 0 && i < Map.size() && j < Map.front().size())
  165.                     {
  166.                         if (!shortestPaths[i][j] && !Map[i][j]) //表示当前节点为New
  167.                         {
  168.                             DNode* neighbor = new DNode(i, j, cur_min);
  169.                             insert(neighbor, cur_min->H + cost(neighbor, cur_min));
  170.                         }
  171.                         else if (shortestPaths[i][j] && !shortestPaths[i][j]->is_obstacle)
  172.                         {
  173.                             if (shortestPaths[i][j]->next == cur_min && shortestPaths[i][j]->H != cur_min->H + cost(cur_min, shortestPaths[i][j]))
  174.                             {
  175.                                 insert(shortestPaths[i][j], cur_min->H + cost(cur_min, shortestPaths[i][j]));
  176.                             }
  177.                             else
  178.                             {
  179.                                 if (shortestPaths[i][j]->next != cur_min)
  180.                                 {
  181.                                     int temp = (shortestPaths[i][j]->H + cost(shortestPaths[i][j], cur_min) >= _cost_max) ? _cost_max : shortestPaths[i][j]->H + cost(shortestPaths[i][j], cur_min);
  182.                                     if (cur_min->H < temp)
  183.                                         insert(cur_min, cur_min->H);
  184.                                     else if (shortestPaths[i][j]->next != cur_min && cur_min->H > shortestPaths[i][j]->H + cost(shortestPaths[i][j], cur_min)
  185.                                         && shortestPaths[i][j]->state == Closed && shortestPaths[i][j]->K > K_old)
  186.                                     {
  187.                                         insert(shortestPaths[i][j], shortestPaths[i][j]->H);
  188.                                     }
  189.                                 }
  190.                             }
  191.                         }
  192.                     }
  193.                 }
  194.             }
  195.         }
  196.         return openlist.top()->K;
  197.     }
  198.     void DStar::setObstacles(const std::vector<std::pair<int, int>>& obstacles)
  199.     {
  200.         if (obstacles.empty())
  201.             return;
  202.         for (const auto& rhs : obstacles)
  203.         {
  204.             if (shortestPaths[rhs.first][rhs.second])
  205.             {
  206.                 shortestPaths[rhs.first][rhs.second]->is_obstacle = true;
  207.                 shortestPaths[rhs.first][rhs.second]->H = _cost_max;
  208.             }
  209.             Map[rhs.first][rhs.second] = '#';
  210.         }
  211.     }
  212.     int DStar::modify(DNode* node)
  213.     {
  214.         DNode* next = node->next;
  215.         openlist.push(next);
  216.         int k_old;
  217.         do {
  218.             k_old = process_state();
  219.             if (k_old == -1)
  220.                 break;
  221.         } while (node->H == _cost_max || k_old < node->H);
  222.         return k_old;
  223.     }
  224.     void DStar::find_first_path(const std::pair<int, int>& start, const std::pair<int, int>& target,
  225.         const std::vector<std::pair<int, int>>& obstacles)
  226.     {
  227.         DNode* end = new DNode(target.first, target.second);
  228.         shortestPaths[target.first][target.second] = end;
  229.         openlist.push(end);
  230.         while (true)
  231.         {
  232.             process_state();
  233.             if (shortestPaths[start.first][start.second] && shortestPaths[start.first][start.second]->state == Closed)
  234.                 break;
  235.         }
  236.         setObstacles(obstacles);
  237.         DNode* begin = shortestPaths[start.first][start.second];
  238.         int i;
  239.         while (begin)
  240.         {
  241.             Map[begin->x][begin->y] = '*';
  242.             if (begin->next && begin->next->is_obstacle)
  243.             {
  244.                 i = modify(begin);
  245.                 if (i == -1)
  246.                 {
  247.                     break;
  248.                 }
  249.             }
  250.             begin = begin->next;
  251.         }
  252.         if (i == -1)
  253.         {
  254.             std::cout << "No New Path To Target" << std::endl;
  255.             return;
  256.         }
  257.         else
  258.         {
  259.             for (const auto& i : Map)
  260.             {
  261.                 for (const auto& j : i)
  262.                 {
  263.                     if (j > 1)
  264.                         std::cout << char(j) << " ";
  265.                     else
  266.                         std::cout << j << " ";
  267.                 }
  268.                 std::cout << std::endl;
  269.             }
  270.         }
  271.     }
  272. }
  1. #include <time.h>
  2. #include"DStar.h"
  3. int main()
  4. {
  5.  
  6.     std::vector<std::vector<int>> map2(25, std::vector<int>(25));
  7.  
  8.     for (int j = 3; j < 8; ++j)
  9.         map2[6][j] = 1;
  10.     for (int j = 4; j < 7; ++j)
  11.         map2[7][j] = 1;
  12.  
  13.     clock_t start = clock();
  14.     DStar::DStar d(map2);
  15.     d.find_first_path({ 3, 2 }, { 23, 16 }, { {12, 4}, {12, 5}, {12, 6}, {12, 7}, {12, 8}, {12, 9}, {12, 10}, {12, 11}, {11, 7}, {13, 3}, {10, 6}, {14, 5}, {6, 2} });
  16.     clock_t ends = clock();
  17.     std::cout << "Running Time : " << (double)(ends - start) / CLOCKS_PER_SEC * 1000 << "ms" << std::endl;
  18.     return 0;
  19. }

原文链接：基于C++的D*算法详解_dstar算法-CSDN博客

2.3 Field D∗

参考文献：https://www.ri.cmu.edu/pub_files/pub4/ferguson_david_2006_3/ferguson_david_2006_3.pdf

原文链接：Field Ｄ*路径规划算法_field d*-CSDN博客

2.4Theta*

参考文献：http://idm-lab.org/bib/abstracts/papers/aaai07a.pdf

扩展：Lazy Theta* 

2.5ARA*和AD*

参考文献：https://www.sciencedirect.com/science/article/pii/S000437020800060X

2.6A*结合voronoi图

参考文献：https://ieeexplore.ieee.org/document/4621302

2.7Hybrid A*

参考文献：http://robots.stanford.edu/papers/junior08.pdf

3、State Lattice

参考文献：https://www.cs.cmu.edu/~alonzo/pubs/papers/TrajGenSubmitFinalCompressed.pdf

二、基于采样的global planner

1、PRM(Probabilistic Roadmap Method)

 参考文献：Sci-Hub | Probabilistic roadmaps for path planning in high-dimensional configuration spaces | 10.1109/70.508439

2、RRT 

参考文献：Randomized kinodynamic planning | IEEE Conference Publication | IEEE Xplore 

3、RRT* 

参考文献： Optimal motion planning with the half-car dynamical model for autonomous high-speed driving | IEEE Conference Publication | IEEE Xplore

三、基于插值的曲线planner 

1、Lines and Circles 

参考文献： Sci-Hub | [IEEE 2013 American Control Conference (ACC) - Washington, DC (2013.6.17-2013.6.19)] 2013 American Control Conference - Optimal motion planning with the half-car dynamical model for autonomous high-speed driving | 10.1109/acc.2013.6579835

2、 Clothoid Curves

参考文献： Real-time Approximation of Clothoids With Bounded Error for Path Planning Applications | IEEE Journals & Magazine | IEEE Xplore

 3、多项式差值曲线（Polynomial Curves）

参考文献：https://www.ri.cmu.edu/pub_files/2012/5/ICRA12_xuwd_Final.pdf

 4. 贝塞尔曲线（Bézier Curves）

参考文献：Continuous curvature planning with obstacle avoidance capabilities in urban scenarios | IEEE Conference Publication | IEEE Xplore

5. 样条曲线（Spline Curves）

参考文献： Pythagorean—Hodograph Curves

四、基于数值优化的planner（最优化理论）

       需要构建优化模型，设置目标函数，并考虑各种约束，比如运动学、动力学、障碍物、舒适性、安全性等等。 

五、总结

      最常用的是基于插值的曲线路径生成，其次是基于图搜索的路径规划，其中最长用的是lattice planner。

     从控制的角度来看，必须考虑多种约束，从车辆运动学限制到乘客舒适度。最近的发展旨在在规划阶段考虑这些限制因素，从而实现平滑和可实现的轨迹，减少控制阶段的限制。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/623604
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号