Carla_plexe.md

../../../Engine/DeriverDataCache

export CC=/home/ujs/UnrealEngine_4.26/Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux/Linux_x64/v17_clang-10.0.1-centos7/x86_64-unknown-linux-gnu/bin/clang export CXX=/home/ujs/UnrealEngine_4.26/Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux/Linux_x64/v17_clang-10.0.1-centos7/x86_64-unknown-linux-gnu/bin/clang++

Carla_plexe

其实大项目考验的就是心智模型，做到一定规模之后就会越做越慢。

Have network and diskplay

docker run -it --network=host -e DISPLAY=:1 --privileged --gpus all --cpus=0 --memory=0 af987c2f46b5

OSM to xodr

osmfilter map.osm --keep="highway=" -o=highways.osm

import carla
import random
import time
import os
client = carla.Client("localhost", 2000)
client.set_timeout(19.0)

world = client.get_world()
current_path = os.path.dirname(".")
def load_customized_world(xodr_path, client):
    """
    Load .xodr file and return the carla world object

    Parameters
    ----------
    xodr_path : str
        path to the xodr file

    client : carla.client
        The created CARLA simulation client.
    """
    if os.path.exists(xodr_path):
        with open(xodr_path) as od_file:
            try:
                data = od_file.read()
            except OSError:
                print("file could not be readed.")
                sys.exit()
        print("load opendrive map %r." % os.path.basename(xodr_path))
        vertex_distance = 2.0  # in meters
        max_road_length = 500.0  # in meters
        wall_height = 3.0  # in meters
        extra_width = 0.6  # in meters
        world = client.generate_opendrive_world(
            data,
            carla.OpendriveGenerationParameters(
                vertex_distance=vertex_distance,
                max_road_length=max_road_length,
                wall_height=wall_height,
                additional_width=extra_width,
                smooth_junctions=False,
                enable_mesh_visibility=True,
            ),
        )
        return world
    else:
        print("file not found.")
        return None
xodr_path = "/home/ujs/mycode/carla_plexe/assets/freeway/map_package/IHP_map.xodr"
world = load_customized_world(xodr_path, client)
map = world.get_map()
route = map.get_topology()
waypoints = map.generate_waypoints(18)
for spawn_point in waypoints:
    world.debug.draw_point(spawn_point.transform.location + carla.Location(z=0.5), size=0.1, color=carla.Color(255, 0, 0), life_time=30.0, persistent_lines=True)

for waypoint in waypoints:
    location = waypoint.transform.location
    text_location = carla.Location(location.x, location.y, 2)  # Set z = 2 meters
    text = f'({location.x:.2f}, {location.y:.2f}, {location.z:.2f})'
    world.debug.draw_string(text_location, text, draw_shadow=False, color=carla.Color(r=0, g=255, b=0), life_time=30.0, persistent_lines=True)

def filter_waypoints(waypoints, minX, maxX, minY, maxY, minZ=-10, maxZ=10):
    """
    Filter Carla waypoints based on specified X, Y, Z coordinate ranges.

    Args:
    waypoints (list): List of Carla waypoints to be filtered.
    minX, maxX, minY, maxY, minZ, maxZ (float): Coordinate range for filtering.

    Returns:
    list: Filtered list of waypoints.
    """
    filtered_waypoints = []
    for wp in waypoints:
        loc = wp.transform.location
        if minX <= loc.x <= maxX and minY <= loc.y <= maxY and minZ <= loc.z <= maxZ:
            filtered_waypoints.append(wp)
    return filtered_waypoints
## x: from  -1250 to -1100 y: from 0 to -10 
freewaySpawnPoints = filter_waypoints(waypoints,-1200,-1100,6,10)
for waypoint in freewaySpawnPoints:
    location = waypoint.transform.location
    text_location = carla.Location(location.x, location.y, 2)  # Set z = 2 meters
    text = f'({location.x:.2f}, {location.y:.2f}, {location.z:.2f})'
    world.debug.draw_string(text_location, text, draw_shadow=False, color=carla.Color(r=0, g=255, b=0), life_time=30.0, persistent_lines=True)
    
def spawn_vehicles_on_points(client, vehicle_type, spawn_points):
    world = client.get_world()
    blueprint_library = world.get_blueprint_library()
    vehicle_bp = blueprint_library.find(vehicle_type)
    spawned_vehicles = []

    for spawn_point in spawn_points:
        spawn_point_location = spawn_point.transform.location
        spawn_point_location.z += 1
        try:
            vehicle = world.spawn_actor(vehicle_bp, carla.Transform(spawn_point_location, spawn_point.transform.rotation))
            if vehicle is not None:
                spawned_vehicles.append(vehicle)
        except RuntimeError as e:
            print(f"Failed to spawn vehicle: {e}")

    return spawned_vehicles
 
def apply_throttle_to_vehicles(vehicles):
    for vehicle in vehicles:
        vehicle.apply_control(carla.VehicleControl(throttle=1.0))
vehicles = spawn_vehicles_on_points(client, "vehicle.mitsubishi.fusorosa", freewaySpawnPoints)

while True:
    apply_throttle_to_vehicles(vehicles)
        

def destroy_all_vehicles(world):
    for actor in world.get_actors():
        if actor.type_id.startswith('vehicle.'):
            actor.destroy()
            
destroy_all_vehicles(world)
def trace_route(point_a, point_b)
map = world.get_map()
route = map.get_topology()

# Create a NetworkX graph
G = nx.Graph()
for edge in route:
    wp1, wp2 = edge[0].transform.location, edge[1].transform.location
    wp1_key = (wp1.x, wp1.y, wp1.z)
    wp2_key = (wp2.x, wp2.y, wp2.z)
    # Add edges to the graph
    G.add_edge(wp1_key, wp2_key)  # Add weight if needed

# Define your start and end waypoints
start_location = carla.Location(x=..., y=..., z=...)  # Replace with actual coordinates
end_location = carla.Location(x=..., y=..., z=...)

start_key = (start_location.x, start_location.y, start_location.z)
end_key = (end_location.x, end_location.y, end_location.z)

# Find the shortest path
shortest_path = nx.shortest_path(G, source=start_key, target=end_key)

http://carla-assets.s3.amazonaws.com/20221201_5ec9328.tar.gz

0.9.5: 20190404_c7b464a 0.9.6: 20190710_0097e66 0.9.7: 20191221_c88604b 0.9.8: 20200306_06b6cb1 0.9.9: 20200422_ea5179a 0.9.10: 20200925_88f9ceb 0.9.11: 20201222_232b876 0.9.12: 20210730_564bcdc 0.9.13: 20211112_d5cfa12 0.9.14:


id:
10406158969854180981
is_intersection:
True
is_junction:
True
junction_id:
1901
lane_change:
carla.libcarla.LaneChange.NONE
lane_id:
-1
lane_type:
carla.libcarla.LaneType.Driving
lane_width:
3.5

{'LV': -1, 'FV': -1, 'RV': 1} WARNING: Version mismatch detected: You are trying to connect to a simulator that might be incompatible with this API WARNING: Client API version = 0.9.15 WARNING: Simulator API version = 0.9.15-dirty {'LV': 0, 'FV': 0, 'RV': 2} WARNING: Version mismatch detected: You are trying to connect to a simulator that might be incompatible with this API WARNING: Client API version = 0.9.15 WARNING: Simulator API version = 0.9.15-dirty {'LV': 0, 'FV': 1, 'RV': -1}

在本文提出的异步一致性协议中，每辆车 i 在离散的更新时刻 $t_k^i$ 接收其邻居车辆的位置信息，并根据接收到的信息更新自身的控制输入。具体而言，车辆 i 在区间 $[t_k^i, t_{k+1}^i)$ 内的控制输入为：

u_i(t)=\begin{cases} \varsigma_i \sum_{j\in N_i(t_k^i)} \frac{a_{ij}(t_k^i)}{\sum_{j\in N_i(t_k^i)} a_{ij}(t_k^i)} \big(s_j(t_k^i-\tau_{ij}^k)-s_i(t)+(t-t_k^i+\tau_{ij}^k)v_0+d_{ij}\big) \\ -3\varsigma_i(v_i(t)-v_0) - (3\varsigma_i-1)a_i(t),\quad \mathrm{if}~N_i(t_k^i) \neq \emptyset\\ \varsigma_i(s_i(t_k^i)-s_i(t)+(t-t_k^i)v_0)-3\varsigma_i(v_i(t)-v_0)-(3\varsigma_i-1)a_i(t),\\ \mathrm{otherwise} \end{cases}

其中 $s_i(t)$ , $v_i(t)$ , $a_i(t)$ 分别表示车辆 i 在 t 时刻的位置、速度和加速度， $v_0$ 为参考速度， $d_{ij}$ 为车辆 i 和 j 之间的期望车间距， $N_i(t_k^i)$ 表示车辆 i 在 $t_k^i$ 时刻接收到信息的邻居车辆集合， $a_{ij}(t_k^i)$ 为邻接矩阵的元素， $\tau_{ij}^k$ 为车辆 j 到车辆 i 的通信时延。

可以看出，该异步一致性协议具有以下特点：

每辆车的更新时间 $t_k^i$ 是独立的，由自己的时钟决定，不要求与其他车辆同步。
控制输入需要车辆自身的连续状态信息，因此在每个更新区间内是连续变化的。
邻居车辆的位置信息是在 $t_k^i-\tau_{ij}^k$ 时刻的，带有时间戳，用于补偿通信延迟导致的信息不一致。
若车辆在某个时刻未收到任何邻居信息，则退化为只利用自身信息的控制率。
控制协议缺乏可调的控制增益，只能通过邻接矩阵元素来调节。

在宽松的假设条件下，即异步更新间隔和通信时延可以任意有界，本文证明了如果有效通信拓扑联合包含一棵有向生成树，所提出的异步一致性协议可以使车队渐近实现期望队形和参考速度。这体现了该协议的鲁棒性。该协议为实际车联网中存在通信约束情况下的编队控制提供了一种可行的分布式解决方案。

前车跟随(PF): $u_i = k_v(\dot{x}_{i-1} - \dot{x}_i) + k_s[r(t) - r_d(t)] \end{equation}$$$

其中: $u_i$ 是车辆 i 的控制输入 $k_v$ 是车辆 i 和前车车速差的增益 $\dot{x}_i$ 是车辆 i 的速度 $k_s$ 是车辆 i 与期望值的距离差的增益
$r(t)$ 是期望距离 $r_d(t)$ 是理想期望距离

PF并获取前车加速度信息(PF+): $u_i = k_a \ddot{x}_{i-1}(t) + k_v (\dot{x}_{i-1} - \dot{x}_i) + k_s[r(t) - r_d(t)] \end{equation}$$$

相比PF,该模型增加了前车加速度 $\ddot{x}_{i-1}(t)$ 的增益 $k_a$ 。

Ploeg等人对PF+的线性控制器形式: