動態窗口法（DWA）python

"""
version1.1
Mobile robot motion planning sample with Dynamic Window Approach
結合https://blog.csdn.net/heyijia0327/article/details/44983551來看，里面含中文注釋
符號參考《煤礦救援機器人地圖構建與路徑規划研究》礦大碩士論文
"""

import math
import numpy as np
import matplotlib.pyplot as plt

show_animation = True  # 動畫


class Config(object):
    """
    用來仿真的參數，
    """

    def __init__(self):
        # robot parameter
        self.max_speed = 1.4  # [m/s]  # 最大速度
        # self.min_speed = -0.5  # [m/s]  # 最小速度，設置為可以倒車
        self.min_speed = 0  # [m/s]  # 最小速度，設置為不倒車
        self.max_yawrate = 40.0 * math.pi / 180.0  # [rad/s]  # 最大角速度
        self.max_accel = 0.2  # [m/ss]  # 最大加速度
        self.max_dyawrate = 40.0 * math.pi / 180.0  # [rad/ss]  # 最大角加速度
        self.v_reso = 0.01  # [m/s]，速度分辨率
        self.yawrate_reso = 0.1 * math.pi / 180.0  # [rad/s]，角速度分辨率
        self.dt = 0.1  # [s]  # 采樣周期
        self.predict_time = 3.0  # [s]  # 向前預估三秒
        self.to_goal_cost_gain = 1.0  # 目標代價增益
        self.speed_cost_gain = 1.0  # 速度代價增益
        self.robot_radius = 1.0  # [m]  # 機器人半徑


def motion(x, u, dt):
    """
    :param x: 位置參數，在此叫做位置空間
    :param u: 速度和加速度，在此叫做速度空間
    :param dt: 采樣時間
    :return:
    """
    # 速度更新公式比較簡單，在極短時間內，車輛位移也變化較大
    # 采用圓弧求解如何？
    x[0] += u[0] * math.cos(x[2]) * dt  # x方向位移
    x[1] += u[0] * math.sin(x[2]) * dt  # y
    x[2] += u[1] * dt  # 航向角
    x[3] = u[0]  # 速度v
    x[4] = u[1]  # 角速度w
    # print(x)

    return x


def calc_dynamic_window(x, config):
    """
    位置空間集合
    :param x:當前位置空間,符號參考碩士論文
    :param config:
    :return:目前是兩個速度的交集，還差一個
    """

    # 車輛能夠達到的最大最小速度
    vs = [config.min_speed, config.max_speed,
          -config.max_yawrate, config.max_yawrate]

    # 一個采樣周期能夠變化的最大最小速度
    vd = [x[3] - config.max_accel * config.dt,
          x[3] + config.max_accel * config.dt,
          x[4] - config.max_dyawrate * config.dt,
          x[4] + config.max_dyawrate * config.dt]
    #  print(Vs, Vd)

    # 求出兩個速度集合的交集
    vr = [max(vs[0], vd[0]), min(vs[1], vd[1]),
          max(vs[2], vd[2]), min(vs[3], vd[3])]

    return vr


def calc_trajectory(x_init, v, w, config):
    """
    預測3秒內的軌跡
    :param x_init:位置空間
    :param v:速度
    :param w:角速度
    :param config:
    :return: 每一次采樣更新的軌跡，位置空間垂直堆疊
    """
    x = np.array(x_init)
    trajectory = np.array(x)
    time = 0
    while time <= config.predict_time:
        x = motion(x, [v, w], config.dt)
        trajectory = np.vstack((trajectory, x))  # 垂直堆疊，vertical
        time += config.dt

        # print(trajectory)
    return trajectory


def calc_to_goal_cost(trajectory, goal, config):
    """
    計算軌跡到目標點的代價
    :param trajectory:軌跡搜索空間
    :param goal:
    :param config:
    :return: 軌跡到目標點歐式距離
    """
    # calc to goal cost. It is 2D norm.

    dx = goal[0] - trajectory[-1, 0]
    dy = goal[1] - trajectory[-1, 1]
    goal_dis = math.sqrt(dx ** 2 + dy ** 2)
    cost = config.to_goal_cost_gain * goal_dis

    return cost


def calc_obstacle_cost(traj, ob, config):
    """
    計算預測軌跡和障礙物的最小距離，dist(v,w)
    :param traj:
    :param ob:
    :param config:
    :return:
    """
    # calc obstacle cost inf: collision, 0:free

    min_r = float("inf")  # 距離初始化為無窮大

    for ii in range(0, len(traj[:, 1])):
        for i in range(len(ob[:, 0])):
            ox = ob[i, 0]
            oy = ob[i, 1]
            dx = traj[ii, 0] - ox
            dy = traj[ii, 1] - oy

            r = math.sqrt(dx ** 2 + dy ** 2)
            if r <= config.robot_radius:
                return float("Inf")  # collision

            if min_r >= r:
                min_r = r

    return 1.0 / min_r  # 越小越好


def calc_final_input(x, u, vr, config, goal, ob):
    """
    計算采樣空間的評價函數，選擇最合適的那一個作為最終輸入
    :param x:位置空間
    :param u:速度空間
    :param vr:速度空間交集
    :param config:
    :param goal:目標位置
    :param ob:障礙物
    :return:
    """
    x_init = x[:]
    min_cost = 10000.0
    min_u = u

    best_trajectory = np.array([x])

    # evaluate all trajectory with sampled input in dynamic window
    # v,生成一系列速度，w，生成一系列角速度
    for v in np.arange(vr[0], vr[1], config.v_reso):
        for w in np.arange(vr[2], vr[3], config.yawrate_reso):

            trajectory = calc_trajectory(x_init, v, w, config)

            # calc cost
            to_goal_cost = calc_to_goal_cost(trajectory, goal, config)
            speed_cost = config.speed_cost_gain * (config.max_speed - trajectory[-1, 3])
            ob_cost = calc_obstacle_cost(trajectory, ob, config)
            #  print(ob_cost)

            # 評價函數多種多樣，看自己選擇
            # 本文構造的是越小越好
            final_cost = to_goal_cost + speed_cost + ob_cost

            # search minimum trajectory
            if min_cost >= final_cost:
                min_cost = final_cost
                min_u = [v, w]
                best_trajectory = trajectory

    # print(min_u)
    #  input()

    return min_u, best_trajectory


def dwa_control(x, u, config, goal, ob):
    """
    調用前面的幾個函數，生成最合適的速度空間和軌跡搜索空間
    :param x:
    :param u:
    :param config:
    :param goal:
    :param ob:
    :return:
    """
    # Dynamic Window control

    vr = calc_dynamic_window(x, config)

    u, trajectory = calc_final_input(x, u, vr, config, goal, ob)

    return u, trajectory


def plot_arrow(x, y, yaw, length=0.5, width=0.1):
    """
    arrow函數繪制箭頭
    :param x:
    :param y:
    :param yaw:航向角
    :param length:
    :param width:參數值為浮點數，代表箭頭尾部的寬度，默認值為0.001
    :return:
    length_includes_head：代表箭頭整體長度是否包含箭頭頭部的長度，默認值為False
    head_width：代表箭頭頭部的寬度，默認值為3*width，即尾部寬度的3倍
    head_length：代表箭頭頭部的長度度，默認值為1.5*head_width，即頭部寬度的1.5倍
    shape：參數值為'full'、'left'、'right'，表示箭頭的形狀，默認值為'full'
    overhang：代表箭頭頭部三角形底邊與箭頭尾部直接的夾角關系，通過該參數可改變箭頭的形狀。
    默認值為0，即頭部為三角形，當該值小於0時，頭部為菱形，當值大於0時，頭部為魚尾狀
    """
    plt.arrow(x, y, length * math.cos(yaw), length * math.sin(yaw),
              head_length=1.5 * width, head_width=width)
    plt.plot(x, y)


def main():
    """
    主函數
    :return:
    """
    # print(__file__ + " start!!")
    # 初始化位置空間
    x = np.array([0.0, 0.0, math.pi / 2.0, 0.2, 0.0])

    goal = np.array([10, 10])

    # matrix二維矩陣
    # ob = np.matrix([[-1, -1],
    #                 [0, 2],
    #                 [4.0, 2.0],
    #                 [5.0, 4.0],
    #                 [5.0, 5.0],
    #                 [5.0, 6.0],
    #                 [5.0, 9.0],
    #                 [8.0, 9.0],
    #                 [7.0, 9.0],
    #                 [12.0, 12.0]
    #                 ])
    ob = np.matrix([[0, 2]])
    u = np.array([0.2, 0.0])
    config = Config()
    trajectory = np.array(x)

    for i in range(1000):

        u, best_trajectory = dwa_control(x, u, config, goal, ob)

        x = motion(x, u, config.dt)
        print(x)

        trajectory = np.vstack((trajectory, x))  # store state history

        if show_animation:
            draw_dynamic_search(best_trajectory, x, goal, ob)

        # check goal
        if math.sqrt((x[0] - goal[0]) ** 2 + (x[1] - goal[1]) ** 2) <= config.robot_radius:
            print("Goal!!")

            break

    print("Done")

    draw_path(trajectory, goal, ob, x)


def draw_dynamic_search(best_trajectory, x, goal, ob):
    """
    畫出動態搜索過程圖
    :return:
    """
    plt.cla()  # 清除上次繪制圖像
    plt.plot(best_trajectory[:, 0], best_trajectory[:, 1], "-g")
    plt.plot(x[0], x[1], "xr")
    plt.plot(0, 0, "og")
    plt.plot(goal[0], goal[1], "ro")
    plt.plot(ob[:, 0], ob[:, 1], "bs")
    plot_arrow(x[0], x[1], x[2])
    plt.axis("equal")
    plt.grid(True)
    plt.pause(0.0001)


def draw_path(trajectory, goal, ob, x):
    """
    畫圖函數
    :return:
    """
    plt.cla()  # 清除上次繪制圖像

    plt.plot(x[0], x[1], "xr")
    plt.plot(0, 0, "og")
    plt.plot(goal[0], goal[1], "ro")
    plt.plot(ob[:, 0], ob[:, 1], "bs")
    plot_arrow(x[0], x[1], x[2])
    plt.axis("equal")
    plt.grid(True)
    plt.plot(trajectory[:, 0], trajectory[:, 1], 'r')
    plt.show()


if __name__ == '__main__':
    main()