Dijkstra 路径规划算法在二维仿真环境中的应用 -- Python代码实现

最新推荐文章于 2024-07-14 20:05:15 发布
最新推荐文章于 2024-07-14 20:05:15 发布
阅读量3.8k 收藏 63
点赞数 20
分类专栏： 机器人路径规划 文章标签： 算法 python Dijkstra 路径规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feriman/article/details/113714637
版权

在上一节中，介绍了 Dijkstra 算法的原理以及在图中的应用，这一节将一步步实现 Dijkstra 路径规划算法在二维环境中的路径规划，来进一步加深对 Dijkstra 算法的理解。

所需要用到的 python 库为 matplotlib 和 math。

二维环境的搭建

我们将搭建下图所示的二维环境，其中黑色原点围成的为墙壁障碍物，绿色点为起点（30, 30），红色点为目标点（70，70）。后面需要将所示环境地图转换为栅格地图，所以在此设置栅格地图中栅格的大小为：1.0， 设置移动机器人的半径为： 2.0。
在这里插入图片描述

实现上述环境的代码如下：

# 设置起点，终点
sx, sy = 30, 30
gx, gy = 70, 70

gird_size = 1.0       	  # 栅格的大小
robot_radius = 2.0        # 机器人的半径

# 设置环境地图
ox, oy = [], []

# 设置四条边
for i in range(20, 80):         # 下边
    ox.append(i)
    oy.append(20.0)
for i in range(20, 80):         # 右边
    ox.append(80.0)
    oy.append(i)
for i in range(20, 80):         # 上边
    ox.append(i)
    oy.append(80.0)
for i in range(20, 80):         # 左边
    ox.append(20)
    oy.append(i)
    
# 设置内部的障碍物
for i in range(20, 60):
    ox.append(40)
    oy.append(i)
for i in range(40, 80):
    ox.append(60)
    oy.append(i)

if show:
    plt.plot(ox, oy, '.k')
    plt.plot(sx, sy, 'og')
    plt.plot(gx, gy, 'or')
    plt.axis('equal')
    plt.show()

根据二维环境地图构建栅格地图

根据二维环境地图构建栅格地图的思路是：

  1. 由二维环境地图的数据，可以得到地图的四条边界值，左边界：min_x，右边界：max_x，上边界：max_y，下边界：min_y。
  2. 根据四条边界值以及我们设置的栅格的大小，可以的栅格地图中栅格的行数和列数，即每一行栅格的数量：y_grid_num，每一列栅格的数量：x_grid_num。
  3. 有了栅格的行数以及列数，可以将栅格地图初始化为一个二维数组，初始化每个栅格的占据状态都为 False，即没有被占据。
  4. 扫描二维环境，将障碍物占据的栅格设置为 True，表示该栅格被障碍物占据，机器人无法到达。栅格化后，机器人一步一个栅格，即一个栅格就表示机器人可能到达的一个位置，通过计算障碍物到栅格的距离（即障碍物到机器人的距离）与机器人的半径作比较，从而判断该栅格机器人能否到达。到达不了的栅格，将设置为 True。
def calc_obstacle_grid_map(self, ox, oy):
    """ 构建环境栅格地图 """
    # 1. 获取环境的 上、 下、 左、 右 四个边界值
    self.min_x = round(min(ox))
    self.max_x = round(max(ox))
    self.min_y = round(min(oy))
    self.max_y = round(max(oy))

    # 2. 根据四个边界值和栅格的大小计算 x, y 方向上 栅格的数量
    self.x_grid_num = round((self.max_x - self.min_x) / self.grid_size)
    self.y_grid_num = round((self.max_y - self.min_y) / self.grid_size)

    # 3. 初始化环境栅格地图
    self.obstacle_map = [[False for _ in range(self.x_grid_num)] for _ in range(self.y_grid_num)]

    # 4. 将障碍物占据栅格
    """ 
        遍历每一个 栅格（前两个 for 循环）以及 遍历每一个障碍物（后两个循环）, 并计算障碍物到栅格的距离
        比较该距离和机器人半径的大小，判断该栅格是否应该被障碍物占据
        """
    for ix in range(self.x_grid_num):
        for iy in range(self.y_grid_num):
            x = self.calc_position(ix, self.min_x)
            y = self.calc_position(iy, self.min_y)
            for iox, ioy in zip(ox, oy):
                d = math.sqrt((iox - x)**2 + (ioy - y)**2)
                if d <= self.robot_radius:
                    self.obstacle_map[ix][iy] = True
                    break

其中 ，calc_position() 函数计算的栅格在二维环境中的坐标，其代码如下：

def calc_position(self, index, min_p):
    """ 将栅格转化成在二维环境中的坐标 """
    pos = min_p + index * self.grid_size
    return pos

机器人运动模式

有了栅格地图，接着设置机器人的运动模式，即机器人如何在栅格地图中运动以及运动的消耗是多少。在此设置机器人可以朝着 8 个方向运动，即 上、下、左、右、右上、右下、左上、左下。代码实现如下：

def get_motion_model():
    # dx, dy, cost
    model = [
        [0, 1, 1],      # 上
        [0, -1, 1],     # 下
        [-1, 0, 1],     # 左
        [1, 0, 1],      # 右
        [1, 1, math.sqrt(2)],    # 右上
        [1, -1, math.sqrt(2)],   # 右下
        [-1, -1, math.sqrt(2)],  # 左下
        [-1, 1, math.sqrt(2)]    # 左上
    ]
    return model

至此，环境的搭建以及机器人的属性都已设置完毕。为了方便后序进行路径规划，将每一个栅格表示为一个结点，代码实现如下：

class Node:
    def __init__(self, x, y, cost, parent_index):
        self.x = x      # 栅格的 x 轴索引
        self.y = y      # 栅格的 y 轴索引
        self.cost = cost        # g(n)
        self.parent_index = parent_index       # 当前节点的父节点

接下来就可以进行 Dijkstra 路径规划了。

Dijkstra 路径规划

在此回顾上节中所说的代码框架。

实现代码如下：

def planning(self, sx, sy, gx, gy):
    """ 进行路径规划 """

    # 1. 将机器人的坐标进行结点化
    sx_index = self.calc_xy_index(sx, self.min_x)
    sy_index = self.calc_xy_index(sy, self.min_y)
    gx_index = self.calc_xy_index(gx, self.min_x)
    gy_index = self.calc_xy_index(gy, self.min_y)
    start_node = self.Node(sx_index, sy_index, 0.0, -1)
    goal_node = self.Node(gx_index, gy_index, 0.0, -1)

    # 2. 初始化 open_set, close_set,并将起点放进 open_set 中
    open_set, close_set = dict(), dict()
    open_set[self.calc_index(start_node)] = start_node

    # 3.开始循环
    while True:
        # (1). 取 open_set 中 cost 最小的结点
        c_id = min(open_set, key=lambda o: open_set[o].cost)
        current = open_set[c_id]

        if show:  # 展现路径规划的过程
            plt.plot(self.calc_position(current.x, self.min_x),
                     self.calc_position(current.y, self.min_y), "xc")
            if len(close_set.keys()) % 10 == 0:
                plt.pause(0.001)

		# (2). 判断该节点是否为终点
        if current.x == goal_node.x and current.y == goal_node.y:
             print('Find Goal!')
             goal_node.parent_index = current.parent_index
             goal_node.cost = current.cost
             break

        # (3). 将该节点从 open_set 中取出，并加入到 close_set 中
        del open_set[c_id]
        close_set[c_id] = current

        # (4). 根据机器人的运动模式，在栅格地图中探索当前位置出发到达的下一可能位置
        for move_x, move_y, move_cost in self.robot_motion:
            node = self.Node(current.x + move_x,
                             current.y + move_y,
                             current.cost + move_cost, c_id)
            n_id = self.calc_index(node)

            if n_id in close_set:
                continue

            if not self.verify_node(node):
                continue

            if n_id not in open_set:
                open_set[n_id] = node   # 发现新的结点
            else:
                if open_set[n_id].cost >= node.cost:
                    # 当前节点的路径到目前来说是最优的，进行更新
                    open_set[n_id] = node

	rx, ry = self.calc_final_path(goal_node, close_set)

    return rx, ry

  1. 路径规划是在结点的基础上进行的，而机器人的起点给的是在二维环境中的坐标，所以首先需要将机器人在二维环境中的坐标转化为栅格地图中坐标，然后再转化成结点表示。其中，二维环境的坐标转化为栅格地图中的坐标的函数为：calc_xy_index()，其代码实现如下：

    def calc_xy_index(self, pos, min_p):
    """ 将机器人在二维环境地图中的坐标转化成栅格地图中的坐标 """
    index = round((pos - min_p) / self.grid_size)
    return index

  2. 初始化 open_set，closed_set，并将起点放入到 open_set 中。第一步中已经得到了栅格结点化后的起点，为了方便在 open_set 以及 closed_set 中索引查找，在此再次对栅格结点进行标号索引，标号方式为从左下角向右一行一行进行编号索引。实现函数为：calc_index(),具体实现代码如下：

    def calc_index(self, node):
    """
        将栅格结点化后的地图进行编号索引，从左下角向右一行一行进行编号索引,如下面示例共 9 个节点，编号方式为：
        [7, 8, 9]
        [4, 5, 6]
        [1, 2, 3]
        """
    index = node.y * self.x_grid_num + node.x
    return index

  3. 开始循环查找路径。

    • 取出 open_set 中 cost 最小的结点。

    • 判断该结点是否为终点。如果是，则说明找到目标点，退出循环。

    • 将第一步从 open_set 中取出的结点加入到 closed_set 中。

    • 根据机器人的运动模式，在栅格地图中探索当前位置出发到达的下一可能位置，并更新 open_set。其中，在探索可能到达的下一位置时，需要判断下一位置是否有效，即是否在所给的环境当中以及是否处在障碍物上。这个验证函数为：verify_node()，实现代码如下：

      def verify_node(self, node):
    """ 验证机器人的当前位置是否合理 """
    px = self.calc_position(node.x, self.min_x)
    py = self.calc_position(node.y, self.min_y)

    # 检查当前位置是否在环境内
    if px < self.min_x or px > self.max_x:
        return False
    if py < self.min_x or py > self.max_y:
        return False

    # 检查当前位置是否处于障碍物中
    if self.obstacle_map[node.x][node.y]:
        return False

    return True

  4. 找到目标点后，进行路径回溯。从目标点开始向前回溯，直到回溯到起点。回溯函数为：calc_final_path(),实现代码如下：

    def calc_final_path(self, goal_node, close_set):
    """ 从终点开始进行回溯，生成从起点到终点的最优路径 """
    rx = [self.calc_position(goal_node.x, self.min_x)]
    ry = [self.calc_position(goal_node.y, self.min_y)]

    parent_index = goal_node.parent_index
    while parent_index != -1:
        n = close_set[parent_index]
        rx.append(self.calc_position(n.x, self.min_x))
        ry.append(self.calc_position(n.y, self.min_y))
        parent_index = n.parent_index

    return rx, ry

各个地图之间坐标的转化关系为：

地图表示示例如下：

最终的效果如下：
在这里插入图片描述

完整代码如下：

import matplotlib.pyplot as plt
import math


class Dijkstra:

    def __init__(self, ox, oy, grid_size, robot_radius):
        # 初始化地图的情况
        self.min_x = None
        self.max_x = None
        self.min_y = None
        self.max_y = None
        self.x_grid_num = None
        self.y_grid_num = None
        self.obstacle_map = None

        self.grid_size = grid_size
        self.robot_radius = robot_radius
        self.calc_obstacle_grid_map(ox, oy)         # 构建环境栅格地图
        self.robot_motion = self.get_motion_model()

    def calc_obstacle_grid_map(self, ox, oy):
        """ 构建环境栅格地图 """
        # 1. 获取环境的 上、 下、 左、 右 四个边界值
        self.min_x = round(min(ox))
        self.max_x = round(max(ox))
        self.min_y = round(min(oy))
        self.max_y = round(max(oy))

        # 2. 根据四个边界值和栅格的大小计算 x, y 方向上 栅格的数量
        self.x_grid_num = round((self.max_x - self.min_x) / self.grid_size)
        self.y_grid_num = round((self.max_y - self.min_y) / self.grid_size)

        # 3. 初始化环境栅格地图
        self.obstacle_map = [[False for _ in range(self.x_grid_num)] for _ in range(self.y_grid_num)]

        # 4. 将障碍物占据栅格
        """ 
        遍历每一个 栅格（前两个 for 循环）以及 遍历每一个障碍物（后两个循环）, 并计算障碍物到栅格的距离
        比较该距离和机器人半径的大小，判断该栅格是否应该被障碍物占据
        """
        for ix in range(self.x_grid_num):
            for iy in range(self.y_grid_num):
                x = self.calc_position(ix, self.min_x)
                y = self.calc_position(iy, self.min_y)
                for iox, ioy in zip(ox, oy):
                    d = math.sqrt((iox - x)**2 + (ioy - y)**2)
                    if d <= self.robot_radius:
                        self.obstacle_map[ix][iy] = True
                        break

    def planning(self, sx, sy, gx, gy):
        """ 进行路径规划 """
        #

        # 1. 将机器人的坐标进行结点化
        sx_index = self.calc_xy_index(sx, self.min_x)
        sy_index = self.calc_xy_index(sy, self.min_y)
        gx_index = self.calc_xy_index(gx, self.min_x)
        gy_index = self.calc_xy_index(gy, self.min_y)
        start_node = self.Node(sx_index, sy_index, 0.0, -1)
        goal_node = self.Node(gx_index, gy_index, 0.0, -1)

        # 2. 初始化 open_set, close_set,并将起点放进 open_set 中
        open_set, close_set = dict(), dict()
        open_set[self.calc_index(start_node)] = start_node

        # 3.开始循环
        while True:
            # (1). 取 open_set 中 cost 最小的结点
            c_id = min(open_set, key=lambda o: open_set[o].cost)
            current = open_set[c_id]

            if show:  # pragma: no cover
                plt.plot(self.calc_position(current.x, self.min_x),
                         self.calc_position(current.y, self.min_y), "xc")
                # for stopping simulation with the esc key.
                # plt.gcf().canvas.mpl_connect(
                #     'key_release_event',
                #     lambda event: [exit(0) if event.key == 'escape' else None])
                if len(close_set.keys()) % 10 == 0:
                    plt.pause(0.001)

            # (2). 判断该节点是否为终点
            if current.x == goal_node.x and current.y == goal_node.y:
                print('Find Goal!')
                goal_node.parent_index = current.parent_index
                goal_node.cost = current.cost
                break

            # (3). 将该节点从 open_set 中取出，并加入到 close_set 中
            del open_set[c_id]
            close_set[c_id] = current

            # (4). 根据机器人的运动模式，在栅格地图中探索当前位置出发到达的下一可能位置
            for move_x, move_y, move_cost in self.robot_motion:
                node = self.Node(current.x + move_x,
                                 current.y + move_y,
                                 current.cost + move_cost, c_id)
                n_id = self.calc_index(node)

                if n_id in close_set:
                    continue

                if not self.verify_node(node):
                    continue

                if n_id not in open_set:
                    open_set[n_id] = node   # 发现新的结点
                else:
                    if open_set[n_id].cost >= node.cost:
                        # 当前节点的路径到目前来说是最优的，进行更新
                        open_set[n_id] = node

        rx, ry = self.calc_final_path(goal_node, close_set)

        return rx, ry

    def calc_final_path(self, goal_node, close_set):
        """ 从终点开始进行回溯，生成从起点到终点的最优路径 """
        rx = [self.calc_position(goal_node.x, self.min_x)]
        ry = [self.calc_position(goal_node.y, self.min_y)]

        parent_index = goal_node.parent_index
        while parent_index != -1:
            n = close_set[parent_index]
            rx.append(self.calc_position(n.x, self.min_x))
            ry.append(self.calc_position(n.y, self.min_y))
            parent_index = n.parent_index

        return rx, ry

    class Node:
        def __init__(self, x, y, cost, parent_index):
            self.x = x      # 栅格的 x 轴索引
            self.y = y      # 栅格的 y 轴索引
            self.cost = cost        # g(n)
            self.parent_index = parent_index       # 当前节点的父节点
        #
        # def __str__(self):
        #     return str(self.x) + "," + str(self.y) + "," + str(self.cost) + "," + str(self.parent_index)

    def calc_index(self, node):
        """
        将栅格化后的地图进行编号索引，从左下角向右一行一行进行编号索引,如下面示例
        [7, 8, 9]
        [4, 5, 6]
        [1, 2, 3]
        """
        index = node.y * self.x_grid_num + node.x
        return index

    def calc_xy_index(self, pos, min_p):
        """ 将机器人在二维环境地图中的坐标转化成栅格地图中的坐标 """
        index = round((pos - min_p) / self.grid_size)
        return index

    def calc_position(self, index, min_p):
        """ 将栅格地图的坐标转化成在真实环境中的坐标 """
        pos = min_p + index * self.grid_size
        return pos

    def verify_node(self, node):
        """ 验证机器人的当前位置是否合理 """
        px = self.calc_position(node.x, self.min_x)
        py = self.calc_position(node.y, self.min_y)

        # 检查当前位置是否在环境内
        if px < self.min_x or px > self.max_x:
            return False
        if py < self.min_x or py > self.max_y:
            return False

        # 检查当前位置是否处于障碍物中
        if self.obstacle_map[node.x][node.y]:
            return False

        return True

    @staticmethod
    def get_motion_model():
        # dx, dy, cost
        model = [
            [0, 1, 1],      # 上
            [0, -1, 1],     # 下
            [-1, 0, 1],     # 左
            [1, 0, 1],      # 右
            [1, 1, math.sqrt(2)],    # 右上
            [1, -1, math.sqrt(2)],   # 右下
            [-1, -1, math.sqrt(2)],  # 左下
            [-1, 1, math.sqrt(2)]    # 左上
        ]
        return model


def main():
    # 设置起点，终点
    sx, sy = 30, 30
    gx, gy = 70, 70

    gird_size = 1.0       # 栅格的大小
    robot_radius = 2.0        # 机器人的半径

    # 设置环境地图
    ox, oy = [], []

    # 设置四条边
    for i in range(20, 80):         # 下边
        ox.append(i)
        oy.append(20.0)
    for i in range(20, 80):         # 右边
        ox.append(80.0)
        oy.append(i)
    for i in range(20, 80):         # 上边
        ox.append(i)
        oy.append(80.0)
    for i in range(20, 80):         # 左边
        ox.append(20)
        oy.append(i)
    # 设置内部的障碍物
    for i in range(20, 60):
        ox.append(40)
        oy.append(i)
    for i in range(40, 80):
        ox.append(60)
        oy.append(i)

    if show:
        plt.plot(ox, oy, '.k')
        plt.plot(sx, sy, 'og')
        plt.plot(gx, gy, 'or')
        # plt.grid('True')
        plt.axis('equal')
        # plt.show()

    dijkstra = Dijkstra(ox, oy, gird_size, robot_radius)
    rx, ry = dijkstra.planning(sx, sy, gx, gy)

    if show:
        plt.plot(rx, ry, '-r')
        plt.pause(0.01)
        plt.show()


if __name__ == '__main__':
    show = True
    main()

如果本文对您有帮助，记得在下方点赞呦！欢迎在评论区留言讨论！

火山&飘雪
关注
专栏目录
MATLAB算法实战应用案例精讲-【自动驾驶】路径规划
qq_36130719的博客
08-03 2023
轨迹规划是在考虑临时或移动障碍物的前提下做出的规划，解决的是如何在避开障碍物的同时尽量沿着路径走的问题，和你看到地图上指示的路线后虽然是沿着路线走但是仍需要看路看车看人看红绿灯一样，重点在避障和遵守交规。在下面的图中，越黄的结点代表越高的启发式值（移动到目标的代价高），而越黑的结点代表越低的启发式值（移动到目标的代价低）。来选择最终车辆状态。再回答为什么有的论文没有路径规划，可能是因为是室内机器人，园区机器人等小型封闭空间内的运动规划，或者是其他缺少移动障碍物的场景，所以轨迹约等于路径，没有两者之分。
ABB RobotStudio软件二次开发：路径规划实例教程
最新发布
kkchenjj的博客
07-31 914
在ABB RobotStudio软件中，创建自定义路径规划程序是实现机器人自动化任务的关键步骤。这不仅涉及到对机器人运动学的理解，还需要掌握RobotStudio的编程接口。以下是一个创建自定义路径规划程序的示例，我们将使用RAPID语言来实现。在回顾ABB RobotStudio软件的路径规划二次开发流程时，我们主要关注的是如何利用RobotStudio的开放API和二次开发工具，如RAPID编程语言或RobotStudio的Add-In功能，来定制和优化机器人的路径规划。需求分析。
迪杰斯特拉算法MATLAB仿真
05-19
用于求解路径规划算法，Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。Dijkstra一般的表述通常有两种方式，一种用永久和临时标号方式，一种是用OPEN, CLOSE表的方式，这里均采用永久和临时标号的方式。注意该算法要求图中不存在负权边。
Python-遗传算法路径规划及仿真
08-10
用于带障碍的路径规划仿真及可视化，引入了geatpy 进化算法作为示例，可引入其它方法对比其目标函数值。
【智能算法应用】免疫算法求解二维栅格路径规划问题
Logic_9527的博客
07-14 741
1] 梁景润,刘丽桑,陈炯晖,等.多策略优化麻雀搜索算法及其路径规划的应用[J].福建理工大学学报,2023,21(06):605-612.栅格法模型最早由 W.E. Howden 于 1968 年提出，障碍物的栅格用黑色表示，可通过的自由栅格用白色表示。[3] 张恩浩.基于麻雀搜索算法的移动机器人路径规划算法研究[D].重庆理工大学,2022.[2] 邓明杰.面向路径规划的群智能优化算法研究[D].江西理工大学,2023.求解二维路径规划问题时，一般采用八领域搜索。
pythond的执行原理_D*路径规划算法及python实现
weixin_39987138的博客
11-21 453
1、简介“D*算法”的名称源自 Dynamic A Star,最初由Anthony Stentz于“Optimal and Efficient Path Planning for Partially-Known Environments”中介绍。它是一种启发式的路径搜索算法，适合面对周围环境未知或者周围环境存在动态变化的场景。2、算法原理同A*算法类似，D-star通过一个维护一个优先队列（Ope...
路径规划-Dijkstra算法及仿真(Python)
ゃ﹏淸凨ゞ
04-10 1022
Dijkstra流程和基于Python的程序仿真
【Coppeliasim+Python】Python RRT 路径规划与Coppeliasim加载仿真
cxyhjl的博客
12-03 1107
目录UI-xml设计Python：基于采样的运动规划算法RRT路径规划主程序Lua脚本注释仿真界面Coppeliasim加载RRT路径规划结果交互UI1. UI-xml设计xml = [[<ui closeable="false" on-close="closeEventHandler" resizable="true"> <tabs> <t...
基于ROS的室内机器人系统仿真智能机器人环境感知与路径规划课程项目暨第三十届冯如杯科技竞赛参赛项目.zip
05-03
5. **传感器模拟**：在仿真环境中，可能需要使用ROS的模拟器如`Gazebo`，它能模拟多种传感器数据，提供真实世界的物理交互，帮助测试和验证机器人的行为。 6. **控制算法**：了解PID控制器或其他控制理论，用于将...
ROS中的运动控制与路径规划算法深度剖析
# 1. ROS简介与运动控制基础 ## 1.1 ROS概述 Robot Operating System（ROS）是一个灵活的框架...在ROS中，运动控制是机器人领域中的一个重要主题。通过ROS提供的控制器、运动规划和传感器数据等功能，开发者可以实现
MATLAB在机器人控制与路径规划中的应用
# 1. 引言 ## 1.1 机器人控制与路径规划的重要性 机器人控制与路径规划是机器人技术中非常重要的部分。...它不仅可以用于机器人的建模和运动学分析，还可以用于控制器设计和路径规划算法的实现。MATLAB具有直观的界
MATLAB对dijkstra算法的仿真
11-23
这是用MATLAB制作的dijkstra算法的仿真程序，演示算法的过程，帮助理解最短路径dijkstra算法。
Dijkstra算法MATLAB仿真
11-14
这个代码是使用D算法寻找给定矩阵形式的图，来搜索指定节点到其他节点的最短距离，和最短路径。程序需要输入节点数，图的矩阵和指定的节点
Python-路径规划demo
08-10
路径规划demo
基于人工势场法实现车辆路径规划附python代码+仿真结果和运行方法+仿真结果和运行方法.zip
06-02
1.版本：matlab2014/2019a/2021a，内含运行结果，不会运行可私信 2.领域：智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，更多内容可点击博主头像 3.内容：标题所示，对于介绍可点击主页搜索博客 4.适合人群：本科，硕士等教研学习使用 5.博客介绍：热爱科研的Matlab仿真开发者，修心和技术同步精进，matlab项目合作可si信
一个简单的全覆盖路径规划python
05-03
Full Coverage Path Planning,简单实现，往复式的单区域路径规划
python路径规划仿真实验_[python] A*算法基于栅格地图的全局路径规划
weixin_39562340的博客
11-23 1454
# 所有节点的g值并没有初始化为无穷大# 当两个子节点的f值一样时，程序选择最先搜索到的一个作为父节点加入closed# 对相同数值的不同对待，导致不同版本的A*算法找到等长的不同路径# 最后closed表中的节点很多，如何找出最优的一条路径# 撞墙之后产生较多的节点会加入closed表，此时开始删除closed表中不合理的节点，1.1版本的思路# 1.2版本思路，建立每一个节点的方向指针，指向f...
RRT路径规划算法在二维仿真环境中的应用 -- Python代码实现
火山飘雪的博客
02-16 4606
在上一节中，介绍了 RRT 算法的原理，这一节将一步步实现 RRT 路径规划算法在二维环境中的路径规划，来进一步加深对 RRT 算法的理解。 二维环境的搭建 我们将搭建下图所示的二维环境，绿色点为起点（0，0），红色点为目标点（15, 12），黑色的圆表示障碍物。 实现上述环境的代码如下： start = [0, 0] # 起点 goal = [15, 12] # 终点 # 障碍物 （x, y, radiu） obstacle_list = [ (3, 3, 1.5),
python路径规划仿真_路径规划之dijkstra
weixin_33603377的博客
01-14 1167
原理dijkstra也是一种基于图的搜索算法，算法原理也很简单：按照代价排序每次弹出一个代价最小的结点，同样也是一个优先级队列，不过需要注意与Greedy Best First Search的区别(优先级队列，按照与终点的距离排序，每次弹出距离最小的结点)。补充下，dijkstra一定是最优的！其他资料例子这个例子是在开源代码中找到的，我给添加了一些注释；另外该算法虽然是使用python写的，但其...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值