def main_middle(sx,
                sy,
                syaw,
                mx,
                my,
                myaw,
                other_sx,
                other_sy,
                other_syaw,
                other_gx,
                other_gy,
                other_gyaw,
                other_other_x=None,
                other_other_y=None,
                other_other_yaw=None):

    # set obstacles
    global ox, oy

    oox = ox[:]
    ooy = oy[:]

    tox, toy = ox[:], oy[:]
    kdtree = planner.KDTree(np.vstack((tox, toy)).T)

    if vehicle_lib.check_collision(oox, ooy, [mx], [my], [myaw],
                                   kdtree) == False:
        return None, None, None

    vehicle_x, vehicle_y = planner.vehicle.plot_trailer(
        mx, my, myaw, 0.0, True)

    oox_add, ooy_add = add_obstacle(vehicle_x, vehicle_y, oox, ooy)

    path2 = planner.calc_hybrid_astar_path(other_sx, other_sy, other_syaw,
                                           other_gx, other_gy, other_gyaw,
                                           oox_add, ooy_add,
                                           planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)

    if path2 == []:
        print 'The middle state is invalid(2)'
        return None, None, None

    # path generation
    path1 = planner.calc_hybrid_astar_path(sx, sy, syaw, mx, my, myaw, oox,
                                           ooy, planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)
    if path1 == []:
        print 'Cannot find path.(1)'
        return None, None, None

    vehicle.plot_trailer(other_sx, other_sy, other_syaw, 0)
    show_animation(path1, ox, oy, other_sx, other_sy, other_syaw,
                   other_other_x, other_other_y, other_other_yaw)
    show_animation(path2, ox, oy, mx, my, myaw, other_other_x, other_other_y,
                   other_other_yaw)
    plt.pause(0.01)

    return mx, my, myaw
    def estimate_rs_cost(self, sx, sy, syaw, gx, gy, gyaw, ox, oy):

        tox,toy = ox[:], oy[:]
        oox,ooy = ox[:], oy[:]
        kdtree = planner.KDTree(np.vstack((tox, toy)).T)
        nstart = planner.Node(round(sx / planner.XY_GRID_RESOLUTION), round(sy / planner.XY_GRID_RESOLUTION), round(syaw / planner.YAW_GRID_RESOLUTION), True, [sx], [sy], [syaw], [True],
                      0.0, 0.0, -1)
        ngoal = planner.Node(round(gx / planner.XY_GRID_RESOLUTION), round(gy / planner.XY_GRID_RESOLUTION), round(gyaw / planner.YAW_GRID_RESOLUTION), True, [gx], [gy], [gyaw], [True],
                     0.0, 0.0, -1)
        c = planner.calc_config(oox, ooy, planner.XY_GRID_RESOLUTION, planner.YAW_GRID_RESOLUTION)
        isupdated, fpath = planner.update_node_with_analystic_expantion(nstart, ngoal, c, oox, ooy, kdtree)
        if isupdated:
            cost = fpath.cost
            return cost
        else:
            return 10000
def main(x, y, yaw):
    sx = SX  # [m]
    sy = SY  # [m]
    syaw0 = SYAW

    # goal state
    gx = GX  # [m]
    gy = GY  # [m]
    gyaw0 = GYAW

    other_sx = OTHER_SX  # [m]
    other_sy = OTHER_SY  # [m]
    other_syaw0 = OTHER_SYAW

    other_gx = OTHER_GX  # [m]
    other_gy = OTHER_GY  # [m]
    other_gyaw0 = OTHER_GYAW

    mx = x  # [m]
    my = y  # [m]
    myaw0 = yaw

    # set obstacles
    global ox, oy

    oox = ox[:]
    ooy = oy[:]

    tox, toy = ox[:], oy[:]
    kdtree = planner.KDTree(np.vstack((tox, toy)).T)

    if vehicle_lib.check_collision(oox, ooy, [mx], [my], [myaw0],
                                   kdtree) == False:
        return

    # path generation

    vehicle_x, vehicle_y = planner.vehicle.plot_trailer(
        mx, my, myaw0, 0.0, True)
    oox_add, ooy_add = add_obstacle(vehicle_x, vehicle_y, oox, ooy)
    path2 = planner.calc_hybrid_astar_path(other_sx, other_sy, other_syaw0,
                                           other_gx, other_gy, other_gyaw0,
                                           oox_add, ooy_add,
                                           planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)
    if path2 == []:
        print('The middle state is invalid(2)')
        return

    path1 = planner.calc_hybrid_astar_path(sx, sy, syaw0, mx, my, myaw0, oox,
                                           ooy, planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)
    if path1 == []:
        print('Cannot find path.(1)')
        return

    path3 = planner.calc_hybrid_astar_path(mx, my, myaw0, gx, gy, gyaw0, oox,
                                           ooy, planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)

    if path3 == []:
        print('Cannot find path.(3)')
        return

    # global total_cost
    # global final_path1
    # global final_path2
    # global final_path3,final_mx,final_my,final_myaw0
    #
    # if path1.cost + path2.cost + path3.cost < total_cost:
    #     final_path1 = path1
    #     final_path2 = path2
    #     final_path3 = path3
    #     final_mx = mx
    #     final_my = my
    #     final_myaw0 = myaw0

    plt.grid(True)
    plt.axis("equal")
    plt.plot(ox, oy, '.k')
    plt.pause(5)
    show_animation(path1, ox, oy, other_sx, other_sy, other_syaw0)
    show_animation(path2, ox, oy, mx, my, myaw0)
    show_animation(path3, ox, oy, other_gx, other_gy, other_gyaw0)
Ejemplo n.º 4
0
def main(x, y, yaw):
    sx = SX  # [m]
    sy = SY  # [m]
    syaw0 = SYAW

    # goal state
    gx = GX  # [m]
    gy = GY  # [m]
    gyaw0 = GYAW

    other_sx = OTHER_SX  # [m]
    other_sy = OTHER_SY  # [m]
    other_syaw0 = OTHER_SYAW

    other_gx = OTHER_GX  # [m]
    other_gy = OTHER_GY  # [m]
    other_gyaw0 = OTHER_GYAW

    mx = x  # [m]
    my = y  # [m]
    myaw0 = np.deg2rad(yaw)

    # set obstacles
    ox = []
    oy = []

    # for i in range(-8, 8):
    #     ox.append(i)
    #     oy.append(12.0)
    for i in range(-25, -8):
        ox.append(i)
        oy.append(9.0)
    for i in range(8, 25):
        ox.append(i)
        oy.append(9.0)
    for i in range(-25, -8):
        ox.append(i)
        oy.append(4.0)
    for i in range(-3, 5):
        ox.append(-8.0)
        oy.append(i)
    for i in range(-3, 5):
        ox.append(8.0)
        oy.append(i)
    for i in range(8, 25):
        ox.append(i)
        oy.append(4.0)
    # for i in range(-8, 8):
    #     ox.append(i)
    #     oy.append(1.0)
    for i in range(-8, 8):
        ox.append(i)
        oy.append(12.0)
    for i in range(4, 9):
        ox.append(-25)
        oy.append(i)
    for i in range(4, 9):
        ox.append(25)
        oy.append(i)

    oox = ox[:]
    ooy = oy[:]

    tox, toy = ox[:], oy[:]
    kdtree = planner.KDTree(np.vstack((tox, toy)).T)

    # plt.plot(ox,oy,'.k')
    # plt.show()

    if vehicle_lib.check_collision(oox, ooy, [mx], [my], [myaw0],
                                   kdtree) == False:
        return

    # path generation
    path1 = planner.calc_hybrid_astar_path(sx, sy, syaw0, mx, my, myaw0, ox,
                                           oy, planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)
    if path1 == []:
        print 'Cannot find path.(1)'
        return

    vehicle_x, vehicle_y = planner.vehicle.plot_trailer(
        mx, my, myaw0, 0.0, True)

    oox_add, ooy_add = add_obstacle(vehicle_x, vehicle_y, oox, ooy)

    path2 = planner.calc_hybrid_astar_path(other_sx, other_sy, other_syaw0,
                                           other_gx, other_gy, other_gyaw0,
                                           oox_add, ooy_add,
                                           planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)

    if path2 == []:
        print 'The middle state is invalid(2)'
        return

    path3 = planner.calc_hybrid_astar_path(mx, my, myaw0, gx, gy, gyaw0, ox,
                                           oy, planner.XY_GRID_RESOLUTION,
                                           planner.YAW_GRID_RESOLUTION)

    if path3 == []:
        print 'Cannot find path.(3)'
        return

    # global total_cost
    # global final_path1
    # global final_path2
    # global final_path3,final_mx,final_my,final_myaw0
    #
    # if path1.cost + path2.cost + path3.cost < total_cost:
    #     final_path1 = path1
    #     final_path2 = path2
    #     final_path3 = path3
    #     final_mx = mx
    #     final_my = my
    #     final_myaw0 = myaw0

    vehicle.plot_trailer(other_sx, other_sy, other_syaw0, 0)
    show_animation(path1, oox, ooy, other_sx, other_sy, other_syaw0)
    show_animation(path2, oox, ooy, mx, my, myaw0)
    show_animation(path3, oox, ooy, other_gx, other_gy, other_gyaw0)
    plt.show()