精华内容
下载资源
问答
  • python栅格地图上路径规划作图

    千次阅读 多人点赞 2020-03-22 15:12:50
    工具 spyder(python3.7) matplotlib库 在进行路径规划仿真的时候,我们希望最后得到的结果不仅仅是一个 填满数字的数组,而是将它变为更加直观的图片 (spyder数组自带染色,很赞)这是我的A*算法得到的最后的...

    工具 spyder(python3.7)  matplotlib库

    在进行路径规划仿真的时候,我们希望最后得到的结果不仅仅是一个 填满数字的数组,而是将它变为更加直观的图片

    (spyder数组自带染色,很赞)这是我的A*算法得到的最后的结果,数字意义如下:

    数字 0 1 3 4 6
    含义 障碍物 可以通行 被加入openlist的节点 被加入closelist节点 最后的路径

    但是这样的图片表达效果不佳,我寻求了几种可以将它转化为图片的方法

    1.利用pylab中的热图,直接将数组作为参数传入即可得到以下图片

    代码:

    plt.imshow(map_grid, cmap=plt.cm.hot, interpolation='nearest', vmin=0, vmax=10)
    plt.colorbar()
    xlim(-1, 20)  # 设置x轴范围
    ylim(-1, 20)  # 设置y轴范围
    my_x_ticks = np.arange(0, 20, 1)
    my_y_ticks = np.arange(0, 20, 1)
    plt.xticks(my_x_ticks)
    plt.yticks(my_y_ticks)
    plt.grid(True)
    plt.show()

    这种方式在表达效果上优于未染色的数组,但是我没有对imshow的热图(heatmap)进行深入研究,所以该没有研究该如何自定义各个部分的颜色,感兴趣的朋友推荐这篇文章给你们https://www.cnblogs.com/dylancao/p/9993953.html

    2.直接利用matplotlib进行绘图,利用 plot  scatter以及线条控制来表达我们想要的图像

    直接上效果图

    黑色表示障碍物,浅蓝色方块表示加入过openlist的位置,绿色表示加入closelist的位置,蓝色线条表示我们最后的路径

    (是不是感觉好看很多哈哈哈哈)

    代码如下:

    def draw_path(map_grid,obstacle,path,closelist,openlist=None):
    '''
    map_grid为处理好的二维数组
    obstacle到openlist都是整数,为其对应的标志。比如0代表obstacle,那么obstacle位置就填0
    '''
        obstacle_x=[]
        obstacle_y=[]
        path_x=[]
        path_y=[]
        close_list_x=[]
        close_list_y=[]
        open_list_x=[]
        open_list_y=[]
        for i in range(map_grid.shape[0]):
            for j in range(map_grid.shape[1]):
                if map_grid[i][j]==obstacle:   #栅格地图上obstacle为障碍物标识
                    obstacle_x.append(i)
                    obstacle_y.append(j)    
                if map_grid[i][j]==path:   #栅格地图上path为最后搜索得到路径位置标志
                    path_x.append(i)
                    path_y.append(j)
                if map_grid[i][j]==closelist:   #栅格地图上closelist为为闭列表中记录的位置标志
                    close_list_x.append(i)
                    close_list_y.append(j)
                if map_grid[i][j]==openlist:   #栅格地图上openlist为为闭列表中记录的位置标志
                    open_list_x.append(i)
                    open_list_y.append(j)
        plt.figure(figsize=(10,10))  #为了防止x,y轴间隔不一样长,影响最后的表现效果,所以手动设定等长
        plt.xlim(-1,map_grid.shape[0])
        plt.ylim(-1,map_grid.shape[1])
        my_x_ticks = np.arange(0, map_grid.shape[0], 1)
        my_y_ticks = np.arange(0, map_grid.shape[1], 1)
        plt.xticks(my_x_ticks)#我理解为竖线的位置与间隔
        plt.yticks(my_y_ticks)
        plt.grid(True)  #开启栅格
        plt.plot(path_x,path_y,linewidth=3)
        plt.scatter(open_list_x,open_list_y,s=500,c='cyan',marker='s')
        plt.scatter(obstacle_x,obstacle_y,s=500,c='k',marker='s')
        plt.scatter(close_list_x,close_list_y,s=500,c='g',marker='s')
        plt.title("grid map simulation ")
        plt.show()

    简单来讲就是遍历整个地图,然后将需要绘制的障碍物,路径等都通过列表记录下来,最后通过这几行表现出来,但是传入的mapgrid必须是类似本文第一张图那种经过算法处理过的形式

        plt.plot(path_x,path_y,linewidth=3)
        plt.scatter(open_list_x,open_list_y,s=500,c='cyan',marker='s')
        plt.scatter(obstacle_x,obstacle_y,s=500,c='k',marker='s')
        plt.scatter(close_list_x,close_list_y,s=500,c='g',marker='s')

    marker代表点标志,c表示颜色,s表示标志的大小,s的大小需要大家自己手动调整一下,不一定适用。这里有一份速查博客,可以帮你快速选择自己要的颜色和样式 

    说明:这里选择plot来绘制路径是因为plot会自动连线(除非设置linestyle=''),而scatter是绘制散点图,它不会自动连线。

    3.利用OpenCV库进行绘制

    这种方法理论上可行(我没有实践)

    直接通过img=np.zeros(size,dtype='uint8')来创建画布,然后将得到的二维数组做一个比例变换处理(你不希望自己的图只有几百个像素点吧),依靠OpenCV提供的绘图函数来展示内容

    这种方法很麻烦,但是对像素点操作的方式决定了它自由度极高,可以满足很多怪异需求

     

    这里还是推荐大家使用第二种方式,原理简单,在具有一定自由度的情况下也不需要很麻烦操作。

     

     

    展开全文
  • 如何使用python加载栅格地图

    千次阅读 2018-08-05 22:45:51
    如何使用python加载地图 第一次写博客记录平时发现的一些功能。python在数据挖掘,大数据方面已经被大家广泛应用,在GIS方面其实也被大家广泛应用。本文主要介绍python如何加载地图,使你画的图更漂亮。 需要...

    如何使用python加载栅格地图

    第一次写博客记录平时发现的一些功能。python在数据挖掘,大数据方面已经被大家广泛应用,在GIS方面其实也被大家广泛应用。本文主要介绍python如何加载地图,使你画的图更漂亮。

    • 需要python库
    • 读取GeoTIF文件信息
    • Code

    需要python库

    • osgeo
    • opencv

    读取GeoTIF文件信息1

    包含地理信息的文件格式有多种,这里介绍一下TIFF文件以及其中的.TFW文件。
    TFW文件结构很简单。它是一个包含六行内容的ASCII文本文件。可以用任何一个ASCII文本编辑器来打开TFW文件。TFW文件中的内容如下。

    +6.00
    -0.00
    -0.00
    -6.00
    1709053.00
    8107714.00

    下表列出了对TFW文件中的每一行的说明。

    行说明
    1地图单元中的一个象素在X方向上的X分辨率尺度。 //这6个参数解释的很清楚added by zhangjun at 2010-1-5
    2平移量。
    3 旋转量。(角度)
    4地图单元中的一个象素在Y方向上的Y分辨率尺度的负值。
    5象素1,1(左上方)的X地坐标。
    6 象素1,1(左上方)的Y地坐标。

    使用osgeo获得这些信息:
    下面看一下如何获取文件的一些基本信息,需要用到下面的一些函数与属性。

    1.dataset.GetDescription() # 获得栅格的描述信息
    2.dataset.RasterCount # 获得栅格数据集的波段数
    3.dataset.RasterXSize # 栅格数据的宽度 (X 方向上的像素个数)
    4.dataset.RasterYSize # 栅格数据的高度 (Y 方向上的像素个数)
    5.dataset.GetGeoTransform() # 栅格数据的六参数。
    6.GetProjection() # 栅格数据的投影

    详解2
    TFW文件是关于TIFF影像坐标信息的文本文件,ArcInfo、Microstation、AutoCAD等均支持该格式的坐标信息文件。此文件定义了影像象素坐标与实际地理坐标的仿射关系,基本原理如下:

    x’=Ax+By+C
    y’=Dx+Ey+F

    其中:

    x'=象素对应的地理X坐标
    
    y'=象素对应的地理Y坐标
    
    x=象素坐标【列号】
    
    y=象素坐标【行号】
    
    A=X方向上的象素分辨率
    
    D、B=平移和旋转系数
    
    E=Y方向上的象素分辨素
    
    C=栅格地图左上角象素中心X坐标
    
    F=栅格地图左上角象素中心Y坐标
    

    Tip:Tiff文件是图片格式包含有多个通道,使用时ds.GetRasterBand(i)获得了Tiff文件的一个通道,多通道融合可以的到彩色图片。

    Code

    from osgeo import gdal
    import cv2
    gdal.UseExceptions()
    
    ds = gdal.Open('武汉.tif')
    bandg = ds.GetRasterBand(1)
    elevationg = bandg.ReadAsArray()
    
    bandr = ds.GetRasterBand(2)
    elevationr = bandr.ReadAsArray()
    
    bandb = ds.GetRasterBand(3)
    elevationb = bandb.ReadAsArray()
    
    import matplotlib.pyplot as plt
    nrows, ncols = elevationr.shape
    
    elevation= cv2.merge([elevationg,elevationr,elevationb])
    x0, dx, dxdy, y0, dydx, dy = ds.GetGeoTransform()
    
    x1 = x0 + dx * ncols
    y1 = y0 + dy * nrows
    
    
    plt.show()

    读取的Tiff格栅图片

    这样你就可以在地图上画出你想要东西啦。

    展开全文
  • Python 调用 OccupancyGrid 处理栅格地图栅格地图创建订阅者(利用Python解析bag文件)运行可执行程序数据处理 栅格地图 栅格地图中每一个小格的坐标对应一位数组中的一个数据。实际地图中某点坐标 (x,y) 对应栅格...

    栅格地图

    • 栅格地图中每一个小格的坐标对应一位数组中的一个数据。实际地图中某点坐标 (x,y) 对应栅格地图中坐标 [x*map.info.width+y] 。

    • 栅格地图中每个小格的颜色代表的是该格被占用的概率,颜色越深表明被占用率越高,也就是有更高的可能是障碍物/建筑物。概率的范围是[0,100],如果是未知区域可以将该位置的概率设置为-1。

    创建订阅者(利用Python解析bag文件)

    dealOG.py

    #!/usr/bin/env python
    #coding=utf-8
    
    
    import rospy
    from nav_msgs.msg import OccupancyGrid  # map 数据
    
    
    class TestMap(object):
        def __init__(self):
            # Give the node a name
            rospy.init_node('test_map', anonymous=False)
    
            rospy.Subscriber("/map", OccupancyGrid, self.get_map_data, queue_size=10)
    
        def get_map_data(self, msg):
            height = msg.info.height  # pgm 图片属性的像素值(栅格地图初始化大小——高度上的珊格个数)
            width = msg.info.width  # pgm 图片属性的像素值(栅格地图初始化大小中的宽——宽度上的珊格个数)
            origin_x = msg.info.origin.position.x  # ROS 建图的 origin
            origin_y = msg.info.origin.position.y  # ROS 建图的 origin
            resolution = msg.info.resolution  # ROS 建图的分辨率 resolution(栅格地图分辨率对应栅格地图中一小格的长和宽)
            data_size = len(msg.data)
            print(height, width, origin_x, origin_y, resolution, data_size)
    	# (480, 608, -15.4, -12.200000000000001, 0.05000000074505806, 291840)
            
            # 保存数据为 txt 文件
            with open('data.txt', 'w') as f:
                f.write(str(msg.data))
           	print('保存成功')
    
    
    if __name__ == "__main__":
        try:
            TestMap()
            rospy.spin()
        except rospy.ROSInterruptException:
            rospy.loginfo('Test Map terminated.')
    

    运行可执行程序

    # 打开终端一,启动 ros master
    $ roscore
    
    # 打开终端二,回放数据包
    $ rosbag play map_test.bag 
    
    # 打开终端二,创建订阅者
    $ rosrun beginner_tutorials dealOG.py
    

    数据处理

    from collections import defaultdict
    
    # 读取 txt 文本文件, 去收尾括号, 去空格, 以逗号分割
    with open('/home/zhanglei/catkin_ws/src/beginner_tutorials/data.txt', 'r') as f:
        data = f.read().strip('(').strip(')').replace(' ', '').split(',')
    
    # 选取长度相同的两组数据
    d1 = data[100000:100000+100]
    d2 = data[100000+10:100000+110]
    print('\n', d1, '\n', d2)
    
    # 提取发生变化的数据的下标和变化后的值
    dd = defaultdict(list)
    for i, v in enumerate(d2):
        if d2[i] != d1[i]:
            dd[i] = v
    print('\n', dd)
    

    输出:

    
     ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '100', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '100', '100', '0', '0', '0', '0', '0', '0', '0'] 
     ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '100', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '100', '100', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0']
    
     defaultdict(<class 'list'>, {81: '100', 82: '100', 83: '0', 84: '0', 85: '0', 86: '0', 87: '0', 88: '0', 89: '0', 90: '0', 27: '100', 28: '-1', 29: '-1', 30: '-1', 31: '-1', 32: '-1', 33: '-1', 34: '-1', 35: '-1', 36: '-1', 37: '-1', 92: '0', 91: '0'})
    
    

    链接:
    ROS 编译 Python 文件(利用 Python 解析 bag 文件)

    展开全文
  • 本文的算法细节及推导可以参考Sebastian Thrun的《概率机器人》中占用栅格地图构建部分。 1. 导入所需要的库 import numpy as np import math import matplotlib.pyplot as plt import matplotlib.animation as...

    本文的算法细节及推导可以参考Sebastian Thrun的《概率机器人》中占用栅格地图构建部分。

    1. 导入所需要的库

    import numpy as np
    import math
    import matplotlib.pyplot as plt
    import matplotlib.animation as anim
    from IPython.display import HTML
    

    2. 反演测量模型的实现

    在栅格地图的构建中,反演测量模型即根据当下的观测推出栅格有被占用(有障碍)的概率。

    # Calculates the inverse measurement model for a laser scanner.
    # It identifies three regions. The first where no information is available occurs
    # outside of the scanning arc. The second where objects are likely to exist, at the
    # end of the range measurement within the arc. The third are where objects are unlikely
    # to exist, within the arc but with less distance than the range measurement.、
    # num_rows和num_cols是栅格的参数,x、y和theta是车辆的位姿,meas_phi和meas_r是基于车辆的测量值,
    # rmax是激光雷达的最大量程,alpha和beta是扇形区域的参数
    def inverse_scanner(num_rows, num_cols, x, y, theta, meas_phi, meas_r, rmax, alpha, beta):
        m = np.zeros((M, N))
        for i in range(num_rows):
            for j in range(num_cols):
                # Find range and bearing relative to the input state (x, y, theta).
                r = math.sqrt((i - x)**2 + (j - y)**2)
                phi = (math.atan2(j - y, i - x) - theta + math.pi) % (2 * math.pi) - math.pi
                
                # Find the range measurement associated with the relative bearing.
                k = np.argmin(np.abs(np.subtract(phi, meas_phi)))
                
                # If the range is greater than the maximum sensor range, or behind our range
                # measurement, or is outside of the field of view of the sensor, then no
                # new information is available.
                if (r > min(rmax, meas_r[k] + alpha / 2.0)) or (abs(phi - meas_phi[k]) > beta / 2.0):
                    m[i, j] = 0.5
                
                # If the range measurement lied within this cell, it is likely to be an object.
                elif (meas_r[k] < rmax) and (abs(r - meas_r[k]) < alpha / 2.0):
                    m[i, j] = 0.7
                
                # If the cell is in front of the range measurement, it is likely to be empty.
                elif r < meas_r[k]:
                    m[i, j] = 0.3     
        return m
    

    3. 计算每个光束的range值

    # Generates range measurements for a laser scanner based on a map, vehicle position,
    # and sensor parameters.
    # Uses the ray tracing algorithm.
    # true_map是真实的地图,X代表车辆的状态向量,meas_phi代表测量的角度值,rmax代表激光雷达的最大量程
    # 返回的是对应每个角度值的range值
    def get_ranges(true_map, X, meas_phi, rmax):
        (M, N) = np.shape(true_map)
        x = X[0]
        y = X[1]
        theta = X[2]
        meas_r = rmax * np.ones(meas_phi.shape)
        
        # Iterate for each measurement bearing.
        for i in range(len(meas_phi)):
            # Iterate over each unit step up to and including rmax.
            for r in range(1, rmax+1):
                # Determine the coordinates of the cell.
                xi = int(round(x + r * math.cos(theta + meas_phi[i])))
                yi = int(round(y + r * math.sin(theta + meas_phi[i])))
                
                # If not in the map, set measurement there and stop going further.
                if (xi <= 0 or xi >= M-1 or yi <= 0 or yi >= N-1):
                    meas_r[i] = r
                    break
                # If in the map, but hitting an obstacle, set the measurement range
                # and stop ray tracing.
                elif true_map[int(round(xi)), int(round(yi))] == 1:
                    meas_r[i] = r
                    break
        return meas_r
    

    4. 初始化

    # Simulation time initialization.
    T_MAX = 150
    time_steps = np.arange(T_MAX)# 以步长1生成一个序列
    
    # Initializing the robot's location.
    x_0 = [30, 30, 0]
    
    # The sequence of robot motions.
    u = np.array([[3, 0, -3, 0], [0, 3, 0, -3]])
    u_i = 1
    
    # Robot sensor rotation command
    w = np.multiply(0.3, np.ones(len(time_steps)))
    
    # True map (note, columns of map correspond to y axis and rows to x axis, so 
    # robot position x = x(1) and y = x(2) are reversed when plotted to match
    M = 50
    N = 60
    true_map = np.zeros((M, N))
    true_map[0:10, 0:10] = 1
    true_map[30:35, 40:45] = 1
    true_map[3:6,40:60] = 1;
    true_map[20:30,25:29] = 1;
    true_map[40:50,5:25] = 1;
    
    # Initialize the belief map.
    # We are assuming a uniform prior.
    m = np.multiply(0.5, np.ones((M, N)))
    
    # Initialize the log odds ratio.
    L0 = np.log(np.divide(m, np.subtract(1, m)))
    L = L0
    
    # Parameters for the sensor model.
    meas_phi = np.arange(-0.4, 0.4, 0.05)# 激光雷达的扫描角度
    rmax = 30 # Max beam range.
    alpha = 1 # Width of an obstacle (distance about measurement to fill in).
    beta = 0.05 # Angular width of a beam.
    
    # Initialize the vector of states for our simulation.
    x = np.zeros((3, len(time_steps)))# x不只是三维的,还加了一个时间维度在里面
    x[:, 0] = x_0
    

    5. 主循环

    %%capture
    # Intitialize figures.
    map_fig = plt.figure()
    map_ax = map_fig.add_subplot(111)
    map_ax.set_xlim(0, N)
    map_ax.set_ylim(0, M)
    
    invmod_fig = plt.figure()
    invmod_ax = invmod_fig.add_subplot(111)
    invmod_ax.set_xlim(0, N)
    invmod_ax.set_ylim(0, M)
    
    belief_fig = plt.figure()
    belief_ax = belief_fig.add_subplot(111)
    belief_ax.set_xlim(0, N)
    belief_ax.set_ylim(0, M)
    
    meas_rs = []
    meas_r = get_ranges(true_map, x[:, 0], meas_phi, rmax)
    meas_rs.append(meas_r)
    invmods = []
    invmod = inverse_scanner(M, N, x[0, 0], x[1, 0], x[2, 0], meas_phi, meas_r, \
                             rmax, alpha, beta)
    invmods.append(invmod)
    ms = []
    ms.append(m)
    
    # Main simulation loop.
    for t in range(1, len(time_steps)):
        # Perform robot motion.
        move = np.add(x[0:2, t-1], u[:, u_i]) 
        # If we hit the map boundaries, or a collision would occur, remain still.
        # 直到找到可行的位置,就往那个位置去
        if (move[0] >= M - 1) or (move[1] >= N - 1) or (move[0] <= 0) or (move[1] <= 0) \
            or true_map[int(round(move[0])), int(round(move[1]))] == 1:
            x[:, t] = x[:, t-1]
            u_i = (u_i + 1) % 4
        else:
            x[0:2, t] = move
        x[2, t] = (x[2, t-1] + w[t]) % (2 * math.pi)# 旋转一定的角度,模拟激光雷达的旋转
        
        # TODO Gather the measurement range data, which we will convert to occupancy probabilities
        # using our inverse measurement model.
        # meas_r = ...
        # 根据地图和当下时间步长的车辆位姿,光束角度和激光雷达的最大范围得出每个角度的range值
        meas_r = get_ranges(true_map, x[:, t], meas_phi, rmax)
        meas_rs.append(meas_r)
        
        # TODO Given our range measurements and our robot location, apply our inverse scanner model
        # to get our measure probabilities of occupancy.
        # invmod = ...
        # 根据反演测量模型得出当下时间步长的测量下每个栅格的占据概率
        invmod = inverse_scanner(M, N, x[0, t], x[1, t], x[2, t], meas_phi, meas_r, \
                             rmax, alpha, beta)
        invmods.append(invmod)
        
        # TODO Calculate and update the log odds of our occupancy grid, given our measured
        # occupancy probabilities from the inverse model.
        # L = ...
        # 利用二值贝叶斯滤波算法更新后验概率
        L = L + np.log(np.divide(invmod, np.subtract(1, invmod))) -L0
        
        # TODO Calculate a grid of probabilities from the log odds.
        # m = ...
        # 通过L计算出每个栅格最终的概率
        m = np.divide(1,np.add(1, np.exp(L)))
        m = np.subtract(1, m)
        ms.append(m)
    

    6. 仿真设置

    # Ouput for grading. Do not modify this code!
    m_f = ms[-1]
    
    print("{}".format(m_f[40, 10]))
    print("{}".format(m_f[30, 40]))
    print("{}".format(m_f[35, 40]))
    print("{}".format(m_f[0, 50]))
    print("{}".format(m_f[10, 5]))
    print("{}".format(m_f[20, 15]))
    print("{}".format(m_f[25, 50]))  
    
    def map_update(i):
        map_ax.clear()
        map_ax.set_xlim(0, N)
        map_ax.set_ylim(0, M)
        map_ax.imshow(np.subtract(1, true_map), cmap='gray', origin='lower', vmin=0.0, vmax=1.0)
        x_plot = x[1, :i+1]
        y_plot = x[0, :i+1]
        map_ax.plot(x_plot, y_plot, "bx-")
    
    def invmod_update(i):
        invmod_ax.clear()
        invmod_ax.set_xlim(0, N)
        invmod_ax.set_ylim(0, M)
        invmod_ax.imshow(invmods[i], cmap='gray', origin='lower', vmin=0.0, vmax=1.0)
        for j in range(len(meas_rs[i])):
            invmod_ax.plot(x[1, i] + meas_rs[i][j] * math.sin(meas_phi[j] + x[2, i]), \
                           x[0, i] + meas_rs[i][j] * math.cos(meas_phi[j] + x[2, i]), "ko")
        invmod_ax.plot(x[1, i], x[0, i], 'bx')
        
    def belief_update(i):
        belief_ax.clear()
        belief_ax.set_xlim(0, N)
        belief_ax.set_ylim(0, M)
        belief_ax.imshow(ms[i], cmap='gray', origin='lower', vmin=0.0, vmax=1.0)
        belief_ax.plot(x[1, max(0, i-10):i], x[0, max(0, i-10):i], 'bx-')
        
    map_anim = anim.FuncAnimation(map_fig, map_update, frames=len(x[0, :]), repeat=False)
    invmod_anim = anim.FuncAnimation(invmod_fig, invmod_update, frames=len(x[0, :]), repeat=False)
    belief_anim = anim.FuncAnimation(belief_fig, belief_update, frames=len(x[0, :]), repeat=False)
    

    7. 仿真结果

    7.1 运行轨迹

    HTML(map_anim.to_html5_video())
    

    1

    7.2 反演测量模型

    HTML(invmod_anim.to_html5_video())
    

    2

    7.3 占用栅格地图

    HTML(belief_anim.to_html5_video())
    

    3

    展开全文
  • /usr/bin/env python # -*- coding: utf-8 -*- """ Created on 20-05-13 Updated on 20-05-13 @author: eln @requirements: Ubuntu 16.04.6 LTS, Python 2.7.12 (default, Nov 12 2018, 14:36:49), ROS Version:...
  • (一)高斯栅格地图首先我们来学习三个概念,:1,栅格地图2,高斯分布3,热图(1)栅格地图机器人描述环境,认识环境的过程主要就是依靠地图。它利用环境地图来描述其当前环境信息,并随着使用的算法和传感器采用不同的...
  • 作者:邬杨明 1 import numpy ... 4 # 定义一个含有障碍物的20×20的栅格地图 5 # 10表示可通行点 6 # 0表示障碍物 7 # 7表示起点 8 # 5表示终点 9 map_grid = numpy.full((20, 20), int(10), dtype=n...
  • 《人工智能及应用》鲁斌 import numpy from pylab import * import copy # 定义一个含有障碍物的20×20的栅格地图 # 10表示可通行点 # 0表示障碍物 # 7表示起点 # 5表示终点 map_grid = numpy.full((20, 20), int(10...
  • 利用python可以将栅格数据进行批量裁剪。本程序有个最大的优点就是不需要更改任何代码,可以手动进行选择数据。关于本程序我已经录了视频教程,操作特别简单。https://www.bilibili.com/video/BV1rg4y1z7dY/
  • 前面blog中已经介绍了如何构建家庭智能环保卫士系统数据库,并且给出了生成数据库文件和相应表的具体python代码实现,在数据库构建中,设计了rasterStatusRecord表用于记录室内栅格信息,其中每一条记录表示一个栅格...
  • # 定义一个含有障碍物的20×20的栅格地图 16 # 10表示可通行点 17 # 0表示障碍物 18 # 7表示起点 19 # 5表示终点 20 map_grid = numpy.full(( 20 , 20 ), int ( 10 ), dtype= numpy.int8) 21...
  • 定义一个含有障碍物的20×20的栅格地图 # 10表示可通行点 # 0表示障碍物 # 7表示起点 # 5表示终点 map_grid = numpy.full((20, 20), int(10), dtype= numpy.int8) map_grid[ 3, 3:8] = 0 map_grid[ 3:10,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,504
精华内容 601
关键字:

python栅格地图

python 订阅