Robot Navigation

最新推荐文章于 2025-03-13 14:42:17 发布
最新推荐文章于 2025-03-13 14:42:17 发布
阅读量1.2k 收藏
点赞数
分类专栏： ACM/搜索/BFS ACM/DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/crazy______/article/details/8873092
版权
该博客讨论了如何解决机器人在远程星球上探索时的导航问题。通过接收包含FORWARD、TURN LEFT和TURN RIGHT命令的程序来指定机器人路径。地图以网格形式表示，存在危险点需要避开。目标是找到从起点到目标点的最短路径，并计算不同最短路径的数量，后者对1,000,000取模。输入包括网格大小和详细地图描述，输出是最短路径长度及相应最短路径数量。博主建议使用BFS寻找最短路径，然后结合BFS和动态规划计算方案数，同时注意动态规划过程中避免重复计数。" 104469841,9310448,SpringBoot源码解析：模块结构与自动配置探秘,"['Java', 'Spring', 'Spring Boot', '源码分析']

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Description

Download as PDF

A robot has been sent to explore a remote planet. To specify a path the robot should take, a program is sent each day. The program consists of a sequence of the following commands:

  • FORWARD X: move forward by X units.
  • TURN LEFT: turn left (in place) by 90 degrees.
  • TURN RIGHT: turn right (in place) by 90 degrees.

The robot also has sensor units which allow it to obtain a map of its surrounding area. The map is represented as a grid. Some grid points contain hazards (e.g. craters) and the program must avoid these points or risk losing the robot.

Naturally, if the initial location of the robot, the direction it is facing, and its destination position are known, it is best to send the shortest program (one consisting of the fewest commands) to move the robot to its destination (we do not care which direction it faces at the destination). You are more interested in knowing the number of different shortest programs that can move the robot to its destination. However, the number of shortest programs can be very large, so you are satisfied to compute the number as a remainder modulo 1,000,000.

Input

There will be several test cases in the input. Each test case will begin with a line with two integers


N M


Where N is the number of rows in the grid, andM is the number of columns in the grid ( 2$ \le$N,M$ \le$100). The nextN lines of input will have M characters each. The characters will be one of the following:

  • `.' Indicating a navigable grid point.
  • `*' Indicating a crater (i.e. a non-navigable grid point).
  • `X' Indicating the target grid point. There will be exactly one `X'.
  • `N', `E', `S', or `W' Indicating the starting point and initial heading of the robot. There will be exactly one of these. Note that the directions mirror compass directions on a map: `N' is North (toward the top of the grid), `E' is East (toward the right of the grid), `S' is South (toward the bottom of the grid) and `W' is West (toward the left of the grid).

There will be no spaces and no other characters in the description of the map. The input will end with a line with two0's.

Output

For each test case, output two integers on a single line, with a single space between them. The first is the length of a shortest possible program to navigate the robot from its starting point to the target, and the second is the number of different programs of that length which will get the robot to the target (modulo 1,000,000). If there is no path from the robot to the target, output two zeros separated by a single space. Output no extra spaces, and do not separate answers with blank lines.

Sample Input

5 6
*....X
.....*
.....*
.....*
N....*
6 5
....X
.****
.****
.****
.****
N****
3 3
.E.
***
.X.
0 0

Sample Output

6 4
3 1
0 0

 

先BFS出最短路径，再BFS+动态规划求出方案数。

 

DP时注意去重。

 

#include<cstdio>
#include<cstring>
#include<queue>

using namespace std;

#define Min(a,b) (a<b?a:b)

const int MAXN=200;

int num[4][MAXN][MAXN];
int Hash[4][MAXN][MAXN];
int d[4][MAXN][MAXN];

char ch[MAXN][MAXN];

int st_x,st_y,st_up,la_x,la_y;
int N,M;
int _min;
struct Node{
	int x,y,up;

};

queue<Node> Map;

int OK_(int x,int y)
{
	if(x>=0 && x<N && y>=0 && y<M)
		return 1;
	return 0;
}

void BFS()
{
	int i,j,up,cnt;
	Node tmp,base,top;

	tmp.x=st_x;	tmp.y=st_y;	tmp.up=st_up;
	memset(num,-1,sizeof(num));
	num[tmp.up][tmp.x][tmp.y]=0;

	while(!Map.empty())
		Map.pop();

	Map.push(tmp);

	while(!Map.empty())
	{
		base=Map.front();	Map.pop();
		//		printf("%d %d %d %d\n",base.x,base.y,base.up,num[base.up][base.x][base.y]);
		up=(base.up+1)%4;
		if(num[up][base.x][base.y]==-1)
		{
			tmp.up=up;	tmp.x=base.x;	tmp.y=base.y;
			Map.push(tmp);
			num[tmp.up][tmp.x][tmp.y]=num[base.up][base.x][base.y]+1;
//			printf("x=%d y=%d up=%d num=%d-->x=%d y=%d up=%d num=%d\n",base.x,base.y,base.up,num[base.up][base.x][base.y],tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y]);
		}
		up=(base.up-1);
		if(up<0)
			up+=4;
		if(num[up][base.x][base.y]==-1)
		{
			tmp.up=up;	tmp.x=base.x;	tmp.y=base.y;
			Map.push(tmp);
			num[tmp.up][tmp.x][tmp.y]=num[base.up][base.x][base.y]+1;
//			printf("x=%d y=%d up=%d num=%d-->x=%d y=%d up=%d num=%d\n",base.x,base.y,base.up,num[base.up][base.x][base.y],tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y]);
		}

		if(base.up==1)
		{
			cnt=1;
			while(OK_(base.x,base.y+cnt) && num[base.up][base.x][base.y+cnt]==-1 &&
				(ch[base.x][base.y+cnt]=='.'||ch[base.x][base.y+cnt]=='X'))
			{
				num[base.up][base.x][base.y+cnt]=num[base.up][base.x][base.y]+1;
				tmp.up=base.up;	tmp.x=base.x;	tmp.y=base.y+cnt;
				Map.push(tmp);
//				printf("x=%d y=%d up=%d num=%d-->x=%d y=%d up=%d num=%d\n",base.x,base.y,base.up,num[base.up][base.x][base.y],tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y]);
				cnt++;
			}
		}
		if(base.up==2)
		{
			cnt=1;
			while(OK_(base.x+cnt,base.y) && num[base.up][base.x+cnt][base.y]==-1 &&
				(ch[base.x+cnt][base.y]=='.'||ch[base.x+cnt][base.y]=='X'))
			{
				num[base.up][base.x+cnt][base.y]=num[base.up][base.x][base.y]+1;
				tmp.up=base.up;	tmp.x=base.x+cnt;	tmp.y=base.y;
				Map.push(tmp);
//				printf("x=%d y=%d up=%d num=%d-->x=%d y=%d up=%d num=%d\n",base.x,base.y,base.up,num[base.up][base.x][base.y],tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y]);
				cnt++;
			}
		}
		if(base.up==3)
		{
			cnt=1;
			while(OK_(base.x,base.y-cnt) && num[base.up][base.x][base.y-cnt]==-1 &&
				(ch[base.x][base.y-cnt]=='.'||ch[base.x][base.y-cnt]=='X'))
			{
				num[base.up][base.x][base.y-cnt]=num[base.up][base.x][base.y]+1;
				tmp.up=base.up;	tmp.x=base.x;	tmp.y=base.y-cnt;
				Map.push(tmp);
//				printf("x=%d y=%d up=%d num=%d-->x=%d y=%d up=%d num=%d\n",base.x,base.y,base.up,num[base.up][base.x][base.y],tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y]);
				cnt++;
			}
		}

		if(base.up==0)
		{
			cnt=1;
			while(OK_(base.x-cnt,base.y) && num[base.up][base.x-cnt][base.y]==-1 &&
				(ch[base.x-cnt][base.y]=='.'||ch[base.x-cnt][base.y]=='X'))
			{
				num[base.up][base.x-cnt][base.y]=num[base.up][base.x][base.y]+1;
				tmp.up=base.up;	tmp.x=base.x-cnt;	tmp.y=base.y;
				Map.push(tmp);
//				printf("x=%d y=%d up=%d num=%d-->x=%d y=%d up=%d num=%d\n",base.x,base.y,base.up,num[base.up][base.x][base.y],tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y]);
				cnt++;
			}
		}
	}
}

void D_BFS()
{
	int i,j,k,up,cnt;
	Node tmp,base,top;

	while(!Map.empty())
		Map.pop();

	memset(Hash,0,sizeof(Hash));

	tmp.up=st_up;	tmp.x=st_x;	tmp.y=st_y;
	Map.push(tmp);

	Hash[tmp.up][tmp.x][tmp.y]=1;

	memset(d,0,sizeof(d));
	d[tmp.up][tmp.x][tmp.y]=1;
	while(!Map.empty())
	{
		base=Map.front();	Map.pop();
		if(num[base.up][base.x][base.y]>_min)
			return ;

		up=(base.up+1)%4;
		if(num[up][base.x][base.y]==num[base.up][base.x][base.y]+1)
		{
			d[up][base.x][base.y]=(d[up][base.x][base.y]+d[base.up][base.x][base.y])%1000000;
			tmp.up=up;	tmp.x=base.x;	tmp.y=base.y;
//			printf("x=%d y=%d up=%d num=%d d=%d-->",base.x,base.y,base.up,num[base.up][base.x][base.y],d[base.up][base.x][base.y]);
//				printf("x=%d y=%d up=%d num=%d d=%d\n",tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y],d[tmp.up][tmp.x][tmp.y]);
			if(!Hash[tmp.up][tmp.x][tmp.y])
			{
				Hash[tmp.up][tmp.x][tmp.y]=1;
				Map.push(tmp);
				
			}
		}
		up=(base.up-1);
		if(up<0)
			up+=4;
		if(num[up][base.x][base.y]==num[base.up][base.x][base.y]+1)
		{
			d[up][base.x][base.y]=(d[up][base.x][base.y]+d[base.up][base.x][base.y])%1000000;
			tmp.up=up;	tmp.x=base.x;	tmp.y=base.y;
//			printf("x=%d y=%d up=%d num=%d d=%d-->",base.x,base.y,base.up,num[base.up][base.x][base.y],d[base.up][base.x][base.y]);
//				printf("x=%d y=%d up=%d num=%d d=%d\n",tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y],d[tmp.up][tmp.x][tmp.y]);
			if(!Hash[tmp.up][tmp.x][tmp.y])
			{
				Hash[tmp.up][tmp.x][tmp.y]=1;
				Map.push(tmp);
				
			}
		}

		if(base.up==1)
		{
			cnt=1;
			while(OK_(base.x,base.y+cnt) && (ch[base.x][base.y+cnt]=='.'||ch[base.x][base.y+cnt]=='X') )
			{
				if(num[base.up][base.x][base.y+cnt]==num[base.up][base.x][base.y]+1){
					d[base.up][base.x][base.y+cnt]=(d[base.up][base.x][base.y+cnt]+d[base.up][base.x][base.y])%1000000;
					tmp.up=base.up;	tmp.x=base.x;	tmp.y=base.y+cnt;
//					printf("x=%d y=%d up=%d num=%d d=%d-->",base.x,base.y,base.up,num[base.up][base.x][base.y],d[base.up][base.x][base.y]);
//						printf("x=%d y=%d up=%d num=%d d=%d\n",tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y],d[tmp.up][tmp.x][tmp.y]);
					if(!Hash[tmp.up][tmp.x][tmp.y])
					{
						Hash[tmp.up][tmp.x][tmp.y]=1;
						Map.push(tmp);
						
					}
				}
				cnt++;
			}
		}
		if(base.up==2)
		{
			cnt=1;
			while(OK_(base.x+cnt,base.y) && (ch[base.x+cnt][base.y]=='.'||ch[base.x+cnt][base.y]=='X') )
			{
				if(num[base.up][base.x+cnt][base.y]== num[base.up][base.x][base.y]+1){
					d[base.up][base.x+cnt][base.y]=(d[base.up][base.x+cnt][base.y]+d[base.up][base.x][base.y])%1000000;
					tmp.up=base.up;	tmp.x=base.x+cnt;	tmp.y=base.y;
//					printf("x=%d y=%d up=%d num=%d d=%d-->",base.x,base.y,base.up,num[base.up][base.x][base.y],d[base.up][base.x][base.y]);
//						printf("x=%d y=%d up=%d num=%d d=%d\n",tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y],d[tmp.up][tmp.x][tmp.y]);
					if(!Hash[tmp.up][tmp.x][tmp.y])
					{
						Hash[tmp.up][tmp.x][tmp.y]=1;
						Map.push(tmp);
						
					}
				}
				cnt++;
			}
		}
		if(base.up==3)
		{
			cnt=1;
			while(OK_(base.x,base.y-cnt) && (ch[base.x][base.y-cnt]=='.'||ch[base.x][base.y-cnt]=='X'))
			{
				if(num[base.up][base.x][base.y-cnt]==num[base.up][base.x][base.y]+1 ){
					d[base.up][base.x][base.y-cnt]=(d[base.up][base.x][base.y-cnt]+d[base.up][base.x][base.y])%1000000;
					tmp.up=base.up;	tmp.x=base.x;	tmp.y=base.y-cnt;
//					printf("x=%d y=%d up=%d num=%d d=%d-->",base.x,base.y,base.up,num[base.up][base.x][base.y],d[base.up][base.x][base.y]);
//						printf("x=%d y=%d up=%d num=%d d=%d\n",tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y],d[tmp.up][tmp.x][tmp.y]);
					if(!Hash[tmp.up][tmp.x][tmp.y])
					{
						Hash[tmp.up][tmp.x][tmp.y]=1;
						Map.push(tmp);
						
					}
				}
				cnt++;
			}
		}

		if(base.up==0)
		{
			cnt=1;
			while(OK_(base.x-cnt,base.y) &&	(ch[base.x-cnt][base.y]=='.'||ch[base.x-cnt][base.y]=='X')  )
			{
				if(num[base.up][base.x-cnt][base.y]==num[base.up][base.x][base.y]+1){
					d[base.up][base.x-cnt][base.y]=(d[base.up][base.x-cnt][base.y]+d[base.up][base.x][base.y])%1000000;
					tmp.up=base.up;	tmp.x=base.x-cnt;	tmp.y=base.y;
//					printf("x=%d y=%d up=%d num=%d d=%d-->",base.x,base.y,base.up,num[base.up][base.x][base.y],d[base.up][base.x][base.y]);
//						printf("x=%d y=%d up=%d num=%d d=%d\n",tmp.x,tmp.y,tmp.up,num[tmp.up][tmp.x][tmp.y],d[tmp.up][tmp.x][tmp.y]);
					if(!Hash[tmp.up][tmp.x][tmp.y])
					{
						Hash[tmp.up][tmp.x][tmp.y]=1;
						Map.push(tmp);
						
					}
				}
				cnt++;
			}
		}
	}

}

int main()
{
	int i,j,k;
	int ok,s;
	st_x=-1;st_y=-1;st_up=-1;
	while(scanf("%d%d",&N,&M),N||M)
	{
		for(i=0;i<N;i++)
		{
			scanf("%s",ch[i]);
			for(j=0;j<M;j++)
			{
				if(ch[i][j]=='X')
				{
					la_x=i;	la_y=j;
				}
				else	if(ch[i][j]!='*' && ch[i][j]!='.' )
				{
					st_x=i;	st_y=j;
					if(ch[i][j]=='N')
						st_up=0;
					if(ch[i][j]=='E')
						st_up=1;
					if(ch[i][j]=='S')
						st_up=2;
					if(ch[i][j]=='W')
						st_up=3;
				}
			}
		}
		BFS();
		/*		for(k=0;k<4;k++)
		{
		for(i=0;i<N;i++)
		{
		for(j=0;j<M;j++)
		printf("%d ",num[k][i][j]);
		printf("\n");
		}
		printf("\n");
		}
		*/
		//		printf("OK\n");

		ok=0;
		_min=-1;
		for(i=0;i<4;i++)
		{
			if(num[i][la_x][la_y]!=-1)
			{
				ok=1;
				if(_min==-1)
					_min=num[i][la_x][la_y];
				else
					_min=Min(_min,num[i][la_x][la_y]);
			}
		}
		if(!ok)
		{
			printf("0 0\n");
			continue;
		}
		//		printf("%d ",_min);

		D_BFS();

		s=0;
		for(i=0;i<4;i++)
		{
			if(num[i][la_x][la_y]==_min)
			{
				s=(s+d[i][la_x][la_y])%1000000;
			}
		}
		printf("%d %d\n",_min,s);

	}


	return 0;
}

 

2023 ICRA《Visual Language Maps for Robot Navigation》阅读笔记
qq_44100524的博客
06-13 1551
视觉语言导航可以使用预先训练的现有的视觉语言模型来将图像与对象目标的自然语言描述相匹配，但它与绘制环境的过程仍然脱节，缺乏经典几何地图的空间精度。为了解决这个问题，我们提出了VLMaps，这是一种空间地图表示，它将预训练的视觉语言特征与物理世界的3D重建直接融合在一起。VLMaps可以使用标准探索方法从机器人上的视频馈送中自主构建，并在没有额外标记数据的情况下实现地图的自然语言索引。具体来说，当与大型语言模型（LLM）相结合时，VLMaps可以用于。
[论文笔记]Feature-constrained Active Visual SLAM for Mobile Robot Navigation
weixin_43146899的博客
01-04 1191
Feature-constrained Active Visual SLAM for Mobile Robot Navigation 文主要研究在未知环境下，基于视觉的导航过程中，如何避免跟踪故障。当使用基于特征的视觉同步定位和建图(VSLAM)时，在运动期间需要地图点的连续识别和关联。因此，本文讨论了一个运动规划框架，它考虑了可靠导航的感官约束。本文使用SLAM中可用的信息，并提出一种数据驱动的方法来预测给定姿势中相关的地图点的数量。然后，距离最优路径规划器利用该模型来约束路径，使得每个姿态中的相关地图点
ROS实践（五）机器人自动导航（robot_navigation）
最新发布
qq_1033275663的博客
03-13 1232
机器人导航是指机器人在环境中自主地从一个地点移动到另一个地点的过程。这个过程涉及到多个关键技术，包括定位、路径规划、避障等。机器人导航通常包括以下几个重要部分。
Python：处理Robot Navigation数据集的标签
DeniuHe的博客
12-20 409
import numpy as np import pandas as pd data = np.array(pd.read_csv(r'E:\dataset\未处理数据集\Robot Navigation\sensor_readings_24.csv',header=None)) X = data[:,:-1] y = data[:,-1] label = [] n = len(y) fo...
Python实现决策树多分类和回归（Robotnavigation数据）附数据集和结果.zip
03-05
Python实现决策树多分类和回归（Robotnavigation数据）附数据集和结果
RobotNavigation-master_GUI_AstarMATLAB_
09-29
运行应用程序需要MATLAB。安装所要做的就是将文件复制到本地驱动器上的文件夹中，并使用“SetPath”菜单将该文件夹包含到MATLAB的路径中。执行应用程序必须在MATLAB环境下执行。A-star算法：在MATLAB的命令行中键入“Astar\u GUI”RRT算法：在MATLAB的命令行中输入“RRT\u gui”在这两种情况下，图形用户界面都将打开，在这里可以选择地图、设置参数和运行算法。按“解释”按钮了解更多信息。
探索未来移动机器人导航：LocusRobotics的`robot_navigation`项目
gitblog_00029的博客
04-19 446
探索未来移动机器人导航：LocusRobotics的robot_navigation项目 去发现同类优质开源项目:https://gitcode.com/ 在当今的自动化和物联网世界中，移动机器人的应用越来越广泛，从仓库管理到家庭服务，它们扮演着重要角色。而实现这些智能机器人自主导航的关键在于先进的导航算法和软件框架。在这里，我们要介绍的是团队开源的robot_navigation项目，它为机器人...
Particle Filters for Robot Navigation
01-09
Autonomous navigation is an essential capability for mobile robots. In order to operate robustly, a robot needs to know what the environment looks like, where it is in its environment, and how to ...
导航套件（The Carnegie Mellon Robot Navigation Toolkit）
11-24
Welcome to CARMEN, the Carnegie Mellon Robot Navigation Toolkit. CARMEN is an open-source collection of software for mobile robot control. CARMEN is modular software designed to provide basic ...
Autonomous Mobile Robot Navigation Using
11-24
在给定文件信息中，我们可以提取以下IT知识点： 1. 室内定位技术：文档标题和描述均提到了室内定位技术，这种技术通常用于在室内的环境下定位目标。文档具体提到的是基于RFID标签的室内定位方法。...
凸优化matlab代码轨迹-robotNavigation:机器人导航
05-27
凸优化matlab代码轨迹机器人导航 该存储库是Mahyar Fazlyab等人撰写的论文《时变凸优化的预测-校正内点方法》的实现。 。 tl; dr：下载任何文件夹（1.1、2.0、3.0）； 用MATLAB打开; 键入main（）以查看输出（图形）。 就像一个非常有名的标题所暗示的那样，本文继续建立了一个内点优化方法，该方法适用于目标函数和约束条件本质上是随时间变化的问题。 简而言之，所采用的方法结合了用于预测变化的二阶动力学知识和牛顿方法的一种版本，以校正轨迹并收敛于最优解。 因此，名称为“预测校正”。 然后，通过几个示例使用本文得出的优化方法，其中一个是机器人导航问题。 主要假设： 机器人是球形的，半径已知； 所有障碍物均为已知半径和坐标的球形； 两个障碍之间有足够的空间供机器人穿过； 机器人的初始位置没有任何障碍物。 实施的主要阶段： v1.1-具有固定目标的2D工作区； v2.0-具有时变目标的2D工作空间； v3.0-具有随时间变化目标的3D工作区。 注意，第三步实现看起来很漂亮，但与第二步基本相同。 剧情图例： x_c：初始机器人位置的质心 x_d：物镜的初始位置 蓝线
rto_Robot_Navigation
02-09
待办事项：结构 简介+运行版本的gif 概述/结构（请参阅 rqtgraph 包含已订阅主题，已发布主题，服务，配置（参数）的软件包 如何运行/用法（roslaunch rto_nav ..） 安装（克隆，catkin构建等） 导航 介绍 2D导航堆栈从里程计，传感器流和目标姿势中获取信息，并输出安全的速度命令，该命令将发送到移动基地。 导航堆栈是使用Python实现的，并且基于的结构。 ros导航堆栈中提到的前提条件也与NavPy导航堆栈相关。 在凉亭的虚拟世界中的测试了该算法。 Gif.x： NavPy 结构/概述 在下文中，将简要说明该存储库中的所有软件包。 核心储存库 rto_bringup Contains config, script and launch files for starting the robot in the real-world. rto_core
bitbots_navigation
02-26
bitbots_navigation
ROS 学习篇（八）机器人的导航功能－－navigation
热门推荐
Tansir94的博客
11-04 3万+
ROS 学习篇（八）机器人人的导航功能－－navigation 1. 概述 ROS的二维导航功能包，简单来说，就是根据输入的里程计等传感器的信息流和机器人的全局位置，通过导航算法，计算得出安全可靠的机器人速度控制指令。但是，如何在特定的机器人上实现导航功能包的功能，却是一件较为复杂的工程。作为导航功能包使用的必要先决条件，机器人必须运行ROS，发布tf变换树，并发布使用ROS消息类型的传感器数据。...
Self-supervised DRL with Generalized Computation Graphs for Robot Navigation
dckwin的博客
11-16 521
Abstract Learning-based methods improve as the robot acts in the environment, but are difficult to deploy in the real-world due to their high sample complexity. To address the need to learn complex po...
ROS中robot_navigation中param文件夹参数配置问题
weixin_44294046的博客
08-16 1224
ROS中robot_navigation中param文件夹参数配置问题 转自http://www.cnblogs.com/zjiaxing/p/5559382.html 我们的机器人使用两种导航算法在地图中移动：全局导航（global）和局部导航（local)。这些导航算法通过代价地图来处理地图中的各种信息。一个costmap进行全局规划，在整个环境做长期的规划，而另一个是用于局部规划和避障。 全局导航： 在已建立的地图上做一个远距离目标的路径规划。 局部导航： 在正在建立的地图上做近距离目标同时要实时避开
Navigation源码阅读之robot_pose_ekf
weixin_42048023的博客
11-28 4053
卡尔曼滤波器是传感器融合的利器，而navigation源码中的对于小车感知这一块的处理也是依靠EKF来实现，我们来阅读一下这个包的实现方法，以及网上的贝叶斯滤波的官方API，在实际使用时，可以更快地定位错误与改写。 一、首先看看cmakelists，这个包只生成一个节点，主函数在odom_estimation_node.cpp中，定位到OdomEstimationNode类的构造函数，这里有一溜...
对robot_navigation.launch的深入理解
wo_squirrel的博客
05-22 1101
运行robot_navigation.launch文件可改变参数simulation:=true，设置仿真环境下运行。判断是否仿真：是，则启动simulation_one_robot_with_map.launch这个文件。以上为一些运行launch文件时候可选的参数，该参数仅在launch文件内生效。use_dijkstra全局规划器是否使用dijkstra。sub_ackermann是否订阅ackermann话题。open_rviz是否打开rviz。pub_imu是否发布imu信息。
visual language maps for robot navigation
10-10
视觉语言地图是一种用于机器人导航的工具。它将建筑物、道路和其他重要的地标以图像的形式呈现，以帮助机器人在环境中准确定位和导航。 视觉语言地图通过使用计算机视觉技术，将环境中的重要视觉特征提取出来，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值