コード例 #1
0
ファイル: utils.py プロジェクト: ayjchen1/pylot
def spawn_people(client, world, num_people: int, logger):
    """Spawns people at random locations inside the world.

    Args:
        num_people: The number of people to spawn.
    """
    from carla import command, Transform
    p_blueprints = world.get_blueprint_library().filter('walker.pedestrian.*')
    unique_locs = set([])
    spawn_points = []
    # Get unique spawn points.
    for i in range(num_people):
        attempt = 0
        while attempt < 10:
            spawn_point = Transform()
            loc = world.get_random_location_from_navigation()
            if loc is not None:
                # Transform to tuple so that location is comparable.
                p_loc = (loc.x, loc.y, loc.z)
                if p_loc not in unique_locs:
                    spawn_point.location = loc
                    spawn_points.append(spawn_point)
                    unique_locs.add(p_loc)
                    break
            attempt += 1
        if attempt == 10:
            logger.error('Could not find unique person spawn point')
    # Spawn the people.
    batch = []
    for spawn_point in spawn_points:
        p_blueprint = random.choice(p_blueprints)
        if p_blueprint.has_attribute('is_invincible'):
            p_blueprint.set_attribute('is_invincible', 'false')
        batch.append(command.SpawnActor(p_blueprint, spawn_point))
    # Apply the batch and retrieve the identifiers.
    ped_ids = []
    for response in client.apply_batch_sync(batch, True):
        if response.error:
            logger.info('Received an error while spawning a person: {}'.format(
                response.error))
        else:
            ped_ids.append(response.actor_id)
    # Spawn the person controllers
    ped_controller_bp = world.get_blueprint_library().find(
        'controller.ai.walker')
    batch = []
    for ped_id in ped_ids:
        batch.append(command.SpawnActor(ped_controller_bp, Transform(),
                                        ped_id))
    ped_control_ids = []
    for response in client.apply_batch_sync(batch, True):
        if response.error:
            logger.info('Error while spawning a person controller: {}'.format(
                response.error))
        else:
            ped_control_ids.append(response.actor_id)

    return (ped_ids, ped_control_ids)
コード例 #2
0
def main(argv):
    global pixels_to_check
    target_vehicle_transform = Transform(Location(242, 131.24, 0))
    sensor_transform = Transform(Location(237.7, 132.24, 1.3))
    pixels_to_check = [(200, 370)]
    run_scenario(target_vehicle_transform, sensor_transform)

    target_vehicle_transform = Transform(Location(2, 12, 0))
    sensor_transform = Transform(Location(0, 18, 1.4),
                                 Rotation(pitch=0, yaw=-90, roll=0))
    pixels_to_check = [(500, 400), (600, 400), (500, 350), (600, 350)]
    run_scenario(target_vehicle_transform, sensor_transform)
コード例 #3
0
ファイル: replay.py プロジェクト: ymote/pylot
def main(argv):
    client, world = get_world(FLAGS.simulator_host, FLAGS.simulator_port,
                              FLAGS.simulator_timeout)

    # Replayer time factor is only available in > 0.9.5.
    client.set_replayer_time_factor(0.1)
    print(
        client.replay_file(FLAGS.replay_file, FLAGS.replay_start_time,
                           FLAGS.replay_duration, FLAGS.replay_id))
    # Sleep a bit to allow the server to start the replay.
    time.sleep(1)
    vehicle = world.get_actors().find(FLAGS.replay_id)
    if vehicle is None:
        raise ValueError("There was an issue finding the vehicle.")

    # Install the camera.
    camera_blueprint = world.get_blueprint_library().find('sensor.camera.rgb')
    camera_blueprint.set_attribute('image_size_x',
                                   str(FLAGS.camera_image_width))
    camera_blueprint.set_attribute('image_size_y',
                                   str(FLAGS.camera_image_height))

    transform = Transform(Location(2.0, 0.0, 1.4),
                          Rotation(pitch=0, yaw=0, roll=0))

    camera = world.spawn_actor(camera_blueprint, transform, attach_to=vehicle)

    # Register the callback on the camera.
    camera.listen(process_images)

    time.sleep(20)
コード例 #4
0
    def run(self):
        # Read the vehicle ID from the vehicle ID stream.
        vehicle_id_msg = self._vehicle_id_stream.read()
        vehicle_id = vehicle_id_msg.data
        self._logger.debug("@{}: Received Vehicle ID: {}".format(
            vehicle_id_msg.timestamp, vehicle_id))

        # Connect to the world.
        _, world = get_world(self._flags.simulator_host,
                             self._flags.simulator_port,
                             self._flags.simulator_timeout)

        self._vehicle = get_vehicle_handle(world, vehicle_id)
        self._map = world.get_map()

        # Install the lane-invasion sensor.
        lane_invasion_blueprint = world.get_blueprint_library().find(
            'sensor.other.lane_invasion')

        self._logger.debug("Spawning a lane invasion sensor.")
        self._lane_invasion_sensor = world.spawn_actor(lane_invasion_blueprint,
                                                       Transform(),
                                                       attach_to=self._vehicle)

        # Register the callback on the lane-invasion sensor.
        self._lane_invasion_sensor.listen(self.process_lane_invasion)
コード例 #5
0
 def use_sample(self, sample):
     print('USE_SAMPLE Sample:', sample)
     weather = carla.WeatherParameters(**{k: sample.params._asdict()[k] for k in WEATHER_PARAMS})
     self.world.world.set_weather(weather)
     for obj in sample.objects:
         spawn = Transform(self.snap_to_ground(Location(x=obj.position[0],
                                                        y=-obj.position[1], z=1)),
                           Rotation(yaw=-obj.heading * 180 / math.pi - 90))
         attrs = dict()
         if 'color' in obj._fields:
             color = str(int(obj.color.r * 255)) + ',' \
                 + str(int(obj.color.g * 255)) + ',' + str(int(obj.color.b * 255))
             attrs['color'] = color
         if 'blueprint' in obj._fields:
             attrs['blueprint_filter'] = obj.blueprint
         agent = BrakeAgent
         if 'agent' in obj._fields:
             agent = AGENTS[obj.agent]
         if obj.type in ['Vehicle', 'Car', 'Truck', 'Bicycle', 'Motorcycle']:
             self.world.add_vehicle(agent,
                                    spawn=spawn,
                                    has_collision_sensor=False,
                                    has_lane_sensor=False,
                                    ego=obj is sample.objects[0],
                                    **attrs)
         elif obj.type == 'Pedestrian':
             self.world.add_pedestrian(spawn=spawn, **attrs)
         elif obj.type in ['Prop', 'Trash', 'Cone']:
             self.world.add_prop(spawn=spawn, **attrs)
         else:
             print('Unsupported object type:', obj.type)
コード例 #6
0
 def spawn_vehicles(self):
     self.bp_lib = self.world.get_blueprint_library()
     ego_bp = self.bp_lib.filter('vehicle.tesla.model3')[0]
     spawn_point = Transform(Location(x=392.1, y=10.0, z=0.02), Rotation(yaw=89.6))
     self.ego_vehicle = self.world.spawn_actor(ego_bp, spawn_point)
     self.setup_sensors(self.ego_vehicle)
     self.actor.append(self.ego_vehicle)
     self.ego_vehicle.get_world()
     leading_bp = self.bp_lib.filter('vehicle.audi.a2')[0]
     #leading_bp = self.bp_lib.filter('vehicle.audi.etron')[0]
     #leading_bp = self.bp_lib.filter('vehicle.audi.tt')[0]
     #leading_bp = random.choice(self.bp_lib.filter('vehicle.audi.*'))
     spawn_point_leading = Transform(Location(x=392.1, y=320.0, z=0.0), Rotation(yaw=90))
     self.leading_vehicle = self.world.try_spawn_actor(leading_bp, spawn_point_leading)
     self.leading_vehicle.get_world()
     self.actor.append(self.leading_vehicle)
コード例 #7
0
ファイル: carla_client.py プロジェクト: uoe-agents/IGP2
    def add_agent(self,
                  agent: ip.Agent,
                  rolename: str = None,
                  blueprint: carla.ActorBlueprint = None):
        """ Add a vehicle to the simulation. Defaults to an Audi A2 for blueprints if not explicitly given.

        Args:
            agent: Agent to add.
            rolename: Unique name for the actor to spawn.
            blueprint: Optional blueprint defining the properties of the actor.

        Returns:
            The newly added actor.
        """
        if blueprint is None:
            blueprint_library = self.__world.get_blueprint_library()
            blueprint = blueprint_library.find('vehicle.audi.a2')

        if rolename is not None:
            blueprint.set_attribute('role_name', rolename)

        state = agent.state
        yaw = np.rad2deg(-state.heading)
        transform = Transform(Location(x=state.position[0], y=-state.position[1], z=0.1), Rotation(yaw=yaw))
        actor = self.__world.spawn_actor(blueprint, transform)
        actor.set_target_velocity(Vector3D(state.velocity[0], -state.velocity[1], 0.))

        carla_agent = ip.carla.CarlaAgentWrapper(agent, actor)
        self.agents[carla_agent.agent_id] = carla_agent
コード例 #8
0
ファイル: vehicle.py プロジェクト: cadenai/byodr
 def reset(self, attempt=0):
     logger.info('Resetting ...')
     self._in_carla_autopilot = False
     self._in_reverse = False
     self._destroy()
     #
     blueprint_library = self._world.get_blueprint_library()
     vehicle_bp = blueprint_library.find('vehicle.tesla.model3')
     spawn_points = self._world.get_map().get_spawn_points()
     spawn_id = self._spawn_preferred_id if attempt == 0 and self._spawn_preferred_id >= 0 else np.random.randint(
         len(spawn_points))
     spawn_point = spawn_points[spawn_id]
     try:
         self._actor = self._world.spawn_actor(vehicle_bp, spawn_point)
     except RuntimeError as e:
         if attempt < 4:
             self.reset(attempt + 1)
         else:
             raise e
     logger.info("Spawn point is '{}' with id {}.".format(
         spawn_point, spawn_id))
     # Attach the camera's - defaults at https://carla.readthedocs.io/en/latest/cameras_and_sensors/.
     # Provide the position of the sensor relative to the vehicle.
     # Tell the world to spawn the sensor, don't forget to attach it to your vehicle actor.
     camera_front = self._world.spawn_actor(self._create_camera(),
                                            Transform(
                                                Location(x=1.25, z=1.4)),
                                            attach_to=self._actor)
     camera_rear = self._world.spawn_actor(self._create_camera(),
                                           Transform(
                                               Location(x=-1.0, z=2.0),
                                               Rotation(pitch=180,
                                                        roll=180)),
                                           attach_to=self._actor)
     self._sensors.append(camera_front)
     self._sensors.append(camera_rear)
     # Subscribe to the sensor stream by providing a callback function,
     # this function is called each time a new image is generated by the sensor.
     camera_front.listen(lambda data: self._on_camera(data, camera=0))
     camera_rear.listen(lambda data: self._on_camera(data, camera=1))
     self._traffic_manager.ignore_lights_percentage(self._actor, 100.)
     self._set_weather(use_preset=True)
     # The tracker need recreation through the actor dependency.
     if self._geo_tracker is not None:
         self._geo_tracker.quit()
     self._geo_tracker = GeoTrackerThread(self._world, self._actor)
     self._geo_tracker.start()
コード例 #9
0
def main(args):
    """ The main function that orchestrates the setup of the world, connection
    to the scenario and the subsequent logging of the frames for computation
    of the mIoU.

    Args:
        args: The argparse.Namespace instance that is retrieved from parsing
        the arguments.
    """

    # Setup the world.
    world = setup_world(args.host, args.port, args.delta)

    # Retrieve the ego-vehicle from the simulation.
    ego_vehicle = None
    while ego_vehicle is None:
        print("Waiting for the scenario to be ready ...")
        sleep(1)
        ego_vehicle = retrieve_actor(world, 'vehicle.*', 'hero')
        world.tick()

    # Connect the segmentation camera to the vehicle.
    segmentation_camera_transform = Transform(location=Location(1.0, 0.0, 1.8),
                                              rotation=Rotation(0, 0, 0))
    segmentation_camera, camera_setup = spawn_camera(
        'sensor.camera.semantic_segmentation', segmentation_camera_transform,
        ego_vehicle, *args.res.split('x'))

    # Open the CSV file for writing.
    csv_file = open(args.output, 'w')
    csv_writer = csv.writer(csv_file)

    # Create the cleanup function.
    global CLEANUP_FUNCTION
    CLEANUP_FUNCTION = functools.partial(cleanup_function,
                                         world=world,
                                         cameras=[segmentation_camera],
                                         csv_file=csv_file)

    # Register a callback function with the camera.
    segmentation_camera.listen(
        functools.partial(process_segmentation_images,
                          camera_setup=camera_setup,
                          ego_vehicle=ego_vehicle,
                          speed=args.speed,
                          csv=csv_writer,
                          dump=args.dump))

    try:
        # To keep the thread alive so that the images can be processed.
        while True:
            pass
    except KeyboardInterrupt:
        CLEANUP_FUNCTION()
        sys.exit(0)
コード例 #10
0
 def setup_sensors(self, ego_vehicle):
     camera_bp = self.bp_lib.find('sensor.camera.rgb')
     camera_bp.set_attribute('image_size_x', '800')
     camera_bp.set_attribute('image_size_y', '600')
     camera_bp.set_attribute('fov', '100')
     self.camera = self.world.try_spawn_actor(
                     camera_bp,
                     Transform(Location(x=0.8,y=0.0,z=1.7), Rotation(yaw=0.0)), 
                     attach_to=ego_vehicle)
     self.actor.append(self.camera)
     collision_bp = self.bp_lib.find('sensor.other.collision')
     self.collision = self.world.try_spawn_actor(
                     collision_bp,
                     Transform(),
                     attach_to=self.ego_vehicle)
     self.actor.append(self.collision)
     self.image_queue = queue.Queue()
     self.camera.listen(self.image_queue.put)
     self.collision_queue = queue.Queue()
     self.collision.listen(self.collision_queue.put)
コード例 #11
0
ファイル: utils.py プロジェクト: wnklmx/pylot
    def as_simulator_transform(self):
        """Converts the transform to a simulator transform.

        Returns:
            An instance of the simulator class representing the Transform.
        """
        from carla import Location, Rotation, Transform
        return Transform(
            Location(self.location.x, self.location.y, self.location.z),
            Rotation(pitch=self.rotation.pitch,
                     yaw=self.rotation.yaw,
                     roll=self.rotation.roll))
コード例 #12
0
 def restart(self):
     # Keep same camera config if the camera manager exists.
     cam_index = self.camera_manager.index if self.camera_manager is not None else 0
     cam_pos_index = self.camera_manager.transform_index if self.camera_manager is not None else 0
     # Get a random blueprint.
     # blueprint = random.choice(self.world.get_blueprint_library().filter(self._actor_filter))
     blueprint = random.choice(self.world.get_blueprint_library().filter('toyota'))
     blueprint.set_attribute('role_name', self.actor_role_name)
     if blueprint.has_attribute('color'):
         # color = random.choice(blueprint.get_attribute('color').recommended_values)
         # color = "255,255,255"
         color = self.color
         blueprint.set_attribute('color', color)
     # Spawn the player.
     if self.player is not None:
         print("this is the playert not none")
         spawn_point = self.player.get_transform()
         spawn_point.location.z += 2.0
         spawn_point.rotation.roll = 0.0
         spawn_point.rotation.pitch = 0.0
         self.destroy()
         self.player = self.world.try_spawn_actor(blueprint, spawn_point)
     while self.player is None:
         # def ego_spawn_point(points):
         #     for pt in points:
         #         if pt.location.x < 69 and pt.location.x > 68 and pt.location.y > 6 and pt.location.y < 7:
         #             return pt
         # def hero_spawn_point(points):
         #     for pt in points:
         #         if pt.location.x < 69 and pt.location.x > 68 and pt.location.y > 7.5 and pt.location.y < 10:
         #             return pt
         # spawn_points = self.map.get_spawn_points()
         # spawn_point = random.choice(spawn_points) if spawn_points else carla.Transform()
         # if self.actor_role_name == "hero":
         #     spawn_point = hero_spawn_point(spawn_points)
         # elif self.actor_role_name == "ego_vehicle":
         #     spawn_point = ego_spawn_point(spawn_points)
         # print(" ========================================= ")
         # for i in range(10):
         #     print(" these are all the available spawn points ", spawn_points[i])
         # spawn_point = spawn_points[179]
         spawn_point = Transform(Location(x=self.init_positionx, y=self.init_positiony, z=2.5), Rotation(pitch=1, yaw=180, roll=1))
         self.player = self.world.try_spawn_actor(blueprint, spawn_point)
     # Set up the sensors.
     self.collision_sensor = CollisionSensor(self.player, self.hud)
     self.lane_invasion_sensor = LaneInvasionSensor(self.player, self.hud)
     self.gnss_sensor = GnssSensor(self.player)
     self.camera_manager = CameraManager(self.player, self.hud)
     self.camera_manager.transform_index = cam_pos_index
     self.camera_manager.set_sensor(cam_index, notify=False)
     actor_type = get_actor_display_name(self.player)
     self.hud.notification(actor_type)
コード例 #13
0
def get_inverse_transform_matrix(transform: carla.Transform):
    """
    Get inverse transform matrix from a transform class.

    Inverse transform refers to from world coord system to actor coord system.
    """
    _T = transform.get_inverse_matrix()

    # transform matrix from Actor system to world system
    inverse_trans_matrix = np.array([[_T[0][0], _T[0][1], _T[0][2]],
                                     [_T[1][0], _T[1][1], _T[1][2]],
                                     [_T[2][0], _T[2][1], _T[2][2]]])

    return inverse_trans_matrix
コード例 #14
0
def main():
    """
    main function
    """

    first_goal = Transform()
    first_goal.location.x = 32
    first_goal.location.y = -20
    first_goal.location.z = 0
    first_goal.rotation.pitch = 0
    first_goal.rotation.yaw = 0
    first_goal.rotation.roll = 0

    first_start = Transform()
    first_start.location.x = -10
    first_start.location.y = -96
    first_start.location.z = 0
    first_start.rotation.pitch = 0
    first_start.rotation.yaw = 180
    first_start.rotation.roll = 0

    sub1 = Subscriber("/carla/world_info")
    worldinfo = CarlaWorldInfo()
    sub1.enable()
    sub1.subscribe(worldinfo)

    host = "127.0.0.1"
    port = 2000

    carla_client = carla.Client(host=host, port=port)
    carla_client.set_timeout(2)

    carla_world = carla_client.get_world()

    waypointConverter = CarlaToRosWaypointConverter(carla_world, first_start,
                                                    first_goal)
コード例 #15
0
def get_transform_matrix(transform: carla.Transform):
    """
    Get and parse a transformation matrix by transform.

    Matrix is from Actor coord system to the world coord system.

    :param transform:
    :return trans_matrix: transform matrix in ndarray
    """
    # original trans matrix in list
    _T = transform.get_matrix()

    # transform matrix from Actor system to world system
    trans_matrix = np.array([[_T[0][0], _T[0][1], _T[0][2]],
                             [_T[1][0], _T[1][1], _T[1][2]],
                             [_T[2][0], _T[2][1], _T[2][2]]])

    return trans_matrix
コード例 #16
0
def spawn_rgb_camera(world, location, rotation, vehicle):
    """ This method spawns an RGB camera with the default parameters and the
    given location and rotation. It also attaches the camera to the given
    actor.

    Args:
        world: The world inside the current simulation.
        location: The Location instance representing the location where
          the camera needs to be spawned with respect to the vehicle.
        rotation: The Rotation instance representing the rotation of the
          spawned camera.
        vehicle: The Actor instance to attach the camera to.

    Returns:
        An instance of the camera spawned in the world.
    """
    camera_bp = world.get_blueprint_library().find('sensor.camera.rgb')
    camera_bp.set_attribute('image_size_x', '1280')
    camera_bp.set_attribute('image_size_y', '720')
    transform = Transform(location=location, rotation=rotation)
    return world.spawn_actor(camera_bp, transform, attach_to=vehicle)
コード例 #17
0
 def __init__(self, parent_actor, name, directory, H, W):
     """Constructor method"""
     # self.sensor = None
     self._parent = parent_actor
     self.recording = False
     self.directory = directory
     self.name = name
     self.BEV = np.zeros((3, H, W), dtype=np.uint8)
     world = self._parent.get_world()
     blueprint = world.get_blueprint_library().find(
         'sensor.camera.semantic_segmentation')  #semantic_segmentation
     blueprint.set_attribute('image_size_x', str(W))
     blueprint.set_attribute('image_size_y', str(H))
     blueprint.set_attribute('fov', '90')
     # Set the time in seconds between sensor captures
     blueprint.set_attribute('sensor_tick', '0')
     transform = Transform(Location(z=15), Rotation(pitch=-90))
     self.sensor = world.spawn_actor(blueprint,
                                     transform,
                                     attach_to=self._parent)
     # We need to pass the lambda a weak reference to
     # self to avoid circular reference.
     weak_self = weakref.ref(self)
     self.sensor.listen(lambda image: Camera._parse_image(weak_self, image))
コード例 #18
0
    def Create_actors(self, world, blueprint_library):
        ego_list = []
        npc_list = []
        obstacle_list = []
        sensor_list = []
        # ego车辆设置---------------------------------------------------------------
        ego_bp = blueprint_library.find(id='vehicle.lincoln.mkz2017')
        # 坐标建立
        ego_transform = Transform(
            Location(x=160.341522, y=-371.640472, z=0.281942),
            Rotation(pitch=0.000000, yaw=0.500910, roll=0.000000))
        # 车辆从蓝图定义以及坐标生成
        ego = world.spawn_actor(ego_bp, ego_transform)
        if ego is None:
            print('ego created failed')
        else:
            ego_list.append(ego)
            print('created %s' % ego.type_id)

        # 视角设置------------------------------------------------------------------
        spectator = world.get_spectator()
        # spec_transform = ego.get_transform()
        spec_transform = Transform(
            Location(x=140.341522, y=-375.140472, z=15.281942),
            Rotation(pitch=0.000000, yaw=0.500910, roll=0.000000))
        spec_transform.location += carla.Location(x=60, z=45)
        spec_transform.rotation = carla.Rotation(pitch=-90, yaw=90)
        spectator.set_transform(spec_transform)

        # npc设置--------------------------------------------------------------------
        npc_transform = ego_transform
        for i in range(1):
            npc_transform.location += carla.Location(x=-15, y=-3.5)
            npc_bp = blueprint_library.find(id='vehicle.lincoln.mkz2017')
            npc_bp.set_attribute('color', '229,28,0')
            npc = world.try_spawn_actor(npc_bp, npc_transform)
            if npc is None:
                print('No.%s npc created failed' % i)
            else:
                npc_list.append(npc)
                print('created %s' % npc.type_id)

        # 障碍物设置------------------------------------------------------------------
        obstacle_transform = ego_transform
        for i in range(28):
            if i == 0:
                obsta_bp = blueprint_library.find(
                    id='vehicle.mercedes-benz.coupe')
                obstacle_transform.location += carla.Location(x=95, y=3.8)
                obstacle = world.try_spawn_actor(obsta_bp, obstacle_transform)
                obstacle_transform.location += carla.Location(x=0, y=-5.3)
                if obstacle is None:
                    print('%s obstacle created failed' % i)
                else:
                    obstacle_list.append(obstacle)
                    print('created %s' % obstacle.type_id)
            else:
                obsta_bp = blueprint_library.find(
                    id='static.prop.streetbarrier')
                obstacle_transform.location += carla.Location(x=-3.5, y=7.4)
                obstacle1 = world.try_spawn_actor(obsta_bp, obstacle_transform)
                obstacle_list.append(obstacle1)
                obstacle_transform.location += carla.Location(y=-7.4)
                obstacle2 = world.try_spawn_actor(obsta_bp, obstacle_transform)
                obstacle_list.append(obstacle2)

        # 传感器设置-------------------------------------------------------------------
        ego_collision = SS.CollisionSensor(ego)
        npc_collision = SS.CollisionSensor(npc)
        # lane_invasion = SS.LaneInvasionSensor(ego)
        sensor_list.append(ego_collision)
        sensor_list.append(npc_collision)
        return ego_list, npc_list, obstacle_list, sensor_list
コード例 #19
0
def on_invasion(event):
    print('-----')  # DEBUG
    lane_types = set(x.type for x in event.crossed_lane_markings)
    text = ['%r' % str(x).split()[-1] for x in lane_types]
    print(('Crossed line %s' % ' and '.join(text)))


# #################################################
# Add Camera
camera_bp = blueprint_lib.find('sensor.camera.rgb')
camera_bp.set_attribute('image_size_x', '940')
camera_bp.set_attribute('image_size_y', '500')
camera_bp.set_attribute('sensor_tick', '0.03')

camera_bp_transform = Transform(Location(x=1.9, y=0, z=0.7))
camera = world.spawn_actor(camera_bp,
                           camera_bp_transform,
                           attach_to=vehicle_actor)

# attaching lane invasion sensor
lane_invasion_sensor = world.spawn_actor(lane_invasion_sensor_bp,
                                         Transform(),
                                         attach_to=vehicle_actor)
lane_invasion_sensor.listen(lambda event: on_invasion(event))

time.sleep(1)

camera.listen(lambda image: image_collector(image))

# camera.listen(lambda image: image.save_to_disk('output/%06d.png' %image.frame_number))
コード例 #20
0
import math

import carla
import numpy as np
import pandas as pd
from scipy.interpolate import splprep, splev

from carla import Transform, Location, Rotation

#Easy selfexplaining lambdas
from config import IMAGE_SIZE

numpy_to_transform = lambda point: Transform(
    Location(point[0], point[1], point[2]),
    Rotation(yaw=point[3], pitch=0, roll=0))
transform_to_numpy = lambda transform: np.array([
    transform.location.x, transform.location.y, transform.location.z, transform
    .rotation.yaw
])
numpy_to_location = lambda point: Location(point[0], point[1], point[2])
location_to_numpy = lambda location: np.array(
    [location.x, location.y, location.z])
velocity_to_kmh = lambda v: float(3.6 * np.math.sqrt(v.x**2 + v.y**2 + v.z**2))
numpy_to_velocity_vec = lambda v: carla.Vector3D(x=v[0], y=v[1], z=v[2])


def df_to_spawn_points(data: pd.DataFrame,
                       n: int = 10000,
                       invert: bool = False) -> np.array:
    '''
    Method converting spawnpoints loaded from DataFrame into equally placed points on the map.
コード例 #21
0
ファイル: utils.py プロジェクト: wnklmx/pylot
 def __mul__(self, other):
     new_matrix = np.dot(self.matrix, other.matrix)
     return Transform(matrix=new_matrix)
コード例 #22
0
ファイル: utils.py プロジェクト: wnklmx/pylot
 def inverse_transform(self):
     """Returns the inverse transform of this transform."""
     new_matrix = np.linalg.inv(self.matrix)
     return Transform(matrix=new_matrix)
コード例 #23
0
    for sensor_spec in global_sensors:
        try:
            sensor_names = []
            sensor_type = str('sensor.camera.rgb')
            sensor_id = str(sensor_spec.pop("id"))

            sensor_name = sensor_type + "/" + sensor_id
            if sensor_name in sensor_names:
                raise NameError
            sensor_names.append(sensor_name)

            spawn_point = sensor_spec.pop("spawn_point")
            point = Transform(
                Location(x=spawn_point.pop("x"),
                         y=-spawn_point.pop("y"),
                         z=spawn_point.pop("z")),
                Rotation(pitch=-spawn_point.pop("pitch", 0.0),
                         yaw=-spawn_point.pop("yaw", 0.0),
                         roll=spawn_point.pop("roll", 0.0)))
            # camera_bp.set_attribute('sensor_id',str(sensor_id))

            camera_rgb = world.spawn_actor(camera_bp, point)
            #camera_seg = world.spawn_actor(semseg_bp,point)
            camera_rgb.sensor_name = sensor_id
            #camera_seg.sensor_name = sensor_id + "_seg"
            actor_list.append(camera_rgb)
            #actor_list.append(camera_seg)
            rgb_list.append(camera_rgb)
            print('spawned: ', camera_rgb.sensor_name)
        except RuntimeError as e:
            raise RuntimeError(
コード例 #24
0
ファイル: RL_Control.py プロジェクト: LANYIXING/CARLA_0.9.6_1
    def restart(self):
        # Keep same camera config if the camera manager exists.
        cam_index = self.camera_manager.index if self.camera_manager is not None else 0
        cam_pos_index = self.camera_manager.transform_index if self.camera_manager is not None else 0
        # Get a random blueprint.
        # ******I have made this random.choice just have one choice --> vehicle.bmw.grandtourer
        blueprint = random.choice(self.world.get_blueprint_library().filter(
            self._actor_filter))
        # print("blue print")
        # print(self.world.get_blueprint_library().filter(self._actor_filter))
        blueprint.set_attribute('role_name', 'hero')
        if blueprint.has_attribute('color'):
            color = random.choice(
                blueprint.get_attribute('color').recommended_values)
            # print("color")
            # print(blueprint.get_attribute('color').recommended_values)
            # ****** I have set the blueprint being white as '255,255,255'
            blueprint.set_attribute('color', '255,255,255')
        batch = []
        blueprint2 = random.choice(self.world.get_blueprint_library().filter(
            self._actor_filter))
        blueprint2.set_attribute('role_name', 'hero2')
        if blueprint2.has_attribute('color'):
            blueprint2.set_attribute('color', '0,0,0')
        # batch.append(SpawnActor(blueprint, transform))

        # Spawn the player.

        #     ******************* change positions ****************************
        while self.player is None:
            spawn_points = self.map.get_spawn_points()

            print("length of sapwn_point is %d" % len(spawn_points) +
                  ",just choose one")  # 257 just choose one
            # Transform(Location(x=299.399994, y=129.750000, z=1.320625), Rotation(pitch=0.000000, yaw=179.999756, roll=0.000000))
            spawn_point = spawn_points[2]
            spawn_point1 = Transform(
                Location(x=250, y=129.750000, z=1.320625),
                Rotation(pitch=0.000000, yaw=179.999756, roll=0.000000))
            # print("spawn_point:")
            # print(spawn_point)
            # ********************************* end ***************************
            self.player = self.world.try_spawn_actor(blueprint, spawn_point1)
            # print(self.player.set_velocity(carla.Vector3D(x=-5.0, y=0.000000, z=0.000000)))
            spawn_point2 = Transform(
                Location(x=300, y=129.750000, z=1.320625),
                Rotation(pitch=0.000000, yaw=179.999756, roll=0.000000))

            # self.vehicle2 = self.world.spawn_actor(blueprint2, spawn_point2).set_autopilot(enabled=True)
            # print(self.vehicle2.get_velocity())
            self.vehicle2 = self.world.spawn_actor(blueprint2, spawn_point2)
            self.vehicle2.set_velocity(
                carla.Vector3D(x=-50.0, y=0.000000, z=0.000000))
            # spawn_point3 = Transform(Location(x=280, y=129.750000, z=1.320625),
            #                          Rotation(pitch=0.000000, yaw=179.999756, roll=0.000000))
            # batch.append(self.world.spawn_actor(blueprint2, spawn_point3))
            # batch[0].set_velocity(carla.Vector3D(x=-2.0, y=0.000000, z=0.000000))

        # Set up the sensors.
        self.collision_sensor = CollisionSensor(self.player, self.hud)
        self.lane_invasion_sensor = LaneInvasionSensor(self.player, self.hud)
        self.gnss_sensor = GnssSensor(self.player)
        self.camera_manager = CameraManager(self.player, self.hud)
        self.camera_manager.transform_index = cam_pos_index
        self.camera_manager.set_sensor(cam_index, notify=False)
        actor_type = get_actor_display_name(self.player)
        self.hud.notification(actor_type)
コード例 #25
0
def main(x,y,z,pitch,yaw,roll,sensor_id,port,global_file):
    img_size = np.asarray([960,540],dtype=np.int)
    #pygame.init()
    #display = pygame.display.set_mode((VIEW_WIDTH, VIEW_HEIGHT), pygame.HWSURFACE | pygame.DOUBLEBUF)
    #font = get_font()
    #clock = pygame.time.Clock()

    client = carla.Client('localhost', 2000,1)
    client.set_timeout(20.0)
    # cam_subset=1
    #client.reload_world(False)
    #world = client.get_world()
    world = client.load_world('Town03')
    # weather = carla.WeatherParameters(
    #     cloudiness=0.0,
    #     precipitation=0.0,
    #     sun_altitude_angle=50.0)

    
    #world.set_weather(all_weather[weather_num])
    world.set_weather(getattr(carla.WeatherParameters, "ClearNoon"))
    
    
    # 加入其他车辆
    #Spawn_the_vehicles(world,client,car_num[0])
    ###########相机参数
    # cam_type='cam1'
    
    # with open("/media/wuminghu/hard/hard/carla/cam.txt") as csv_file:
    #     reader = csv.reader(csv_file, delimiter=' ')
    #     for line, row in enumerate(reader):
    #         if row[0] in cam_type:
    #             w_x,w_y,w_yaw,cam_H,cam_pitch=[float(i) for i in row[1:]]
    #             break
    ###########相机参数
    # w_x,w_y,w_yaw,cam_H,cam_pitch=-116,100,100,4,90

    actor_list = []
    rgb_list = []
    camera_bp = world.get_blueprint_library().find('sensor.camera.rgb')
    sizex = str(960)
    sizey = str(540)
    fovcfg = str(90)
    camera_bp.set_attribute('image_size_x',sizex )
    camera_bp.set_attribute('image_size_y', sizey)
    camera_bp.set_attribute('fov', fovcfg)
    semseg_bp = world.get_blueprint_library().find('sensor.camera.semantic_segmentation')
    semseg_bp.set_attribute('image_size_x', sizex)
    semseg_bp.set_attribute('image_size_y', sizey)
    semseg_bp.set_attribute('fov', fovcfg)

    out_path="/home/ubuntu/xwp/datasets/multi_view_dataset/new_test"
    if not os.path.exists(out_path):
        os.makedirs(out_path)
    
    cam_point = Transform(Location(x=x, y=y, z=z),
                Rotation(pitch=pitch, yaw=yaw, roll=roll))

    
    camera_rgb = world.spawn_actor(camera_bp,cam_point)
    camera_seg = world.spawn_actor(semseg_bp,cam_point)
    camera_rgb.sensor_name = sensor_id
    camera_seg.sensor_name = sensor_id + "_seg"  
    actor_list.append(camera_rgb)
    actor_list.append(camera_seg)
    rgb_list .append(camera_rgb)
    print('spawned: ',camera_rgb.sensor_name)

    vehicles_actor = Spawn_the_vehicles(world,client,car_num[0],port)
    print('spawned {} vehicles'.format(len(vehicles_actor)))
    ######################################################file
    with CarlaSyncMode(world, *actor_list, fps=20) as sync_mode:
        count=0
        k=0
        while count<60:
        # while count<100:
            count+=1
            #clock.tick()
            # Advance the simulation and wait for the data.
            #snapshot, image_rgb,image_semseg = sync_mode.tick(timeout=2.0)
            blobs = sync_mode.tick(timeout=2.0)
            if count%10!=0:
                continue
            k+=1
            print(k)

            # img.append(image_rgb)
            #image=image_rgb
            # image1=image_semseg.convert(ColorConverter.CityScapesPalette)
            # import pdb; pdb.set_trace()
            all_images = blobs[1:]
            #images = all_images
            images = all_images[::2]
            semseg_images = all_images[1::2]
            snapshot = blobs[0]
            fps = round(1.0 / snapshot.timestamp.delta_seconds)

            
            world_snapshot = world.get_snapshot()

            actual_actor=[world.get_actor(actor_snapshot.id) for actor_snapshot in world_snapshot]
            got_vehicles=[actor for actor in actual_actor if actor.type_id.find('vehicle')!=-1]

            vehicles_list = []
            for camera_rgb in rgb_list:
                vehicles=[vehicle for vehicle in got_vehicles if vehicle.get_transform().location.distance(camera_rgb.get_transform().location)<65]
                vehicles_list.append(vehicles)
                cam_path = out_path + "/{}".format(camera_rgb.sensor_name)
                if not os.path.exists(cam_path):
                    os.makedirs(cam_path)
                    os.makedirs(cam_path+"/label_2")
                    os.makedirs(cam_path+"/image_2")
                    os.makedirs(cam_path+"/calib")
            # debug = world.debug
            # for vehicle in vehicles:
            #     debug.draw_box(carla.BoundingBox(vehicle.get_transform().location+vehicle.bounding_box.location, vehicle.bounding_box.extent), vehicle.get_transform().rotation, 0.05, carla.Color(255,0,0,0), life_time=0.05)
            # import pdb; pdb.set_trace()
            all_vehicles_list = []
            
            for i,(camera_rgb, vehicles,image,osemseg) in enumerate(zip(rgb_list,vehicles_list,images,semseg_images)):
                v=[] #filtered_vehicles

                # Convert semseg to cv.image
                semseg = np.frombuffer(osemseg.raw_data, dtype=np.dtype("uint8"))
                semseg = np.reshape(semseg, (osemseg.height, osemseg.width, 4))
                semseg = semseg[:, :, :3]
                semseg = semseg[:, :, ::-1]
                # BGR
                # Done

                label_files=open("{}/{}/label_2/{:0>6d}.txt".format(out_path,camera_rgb.sensor_name,k), "w")
                car_2d_bbox=[]
                for car in vehicles:
                    extent = car.bounding_box.extent
                    ###############location
                    car_location =car.bounding_box.location
                    # car_location1=car.get_transform().location
                    cords = np.zeros((1, 4))
                    cords[0, :]=np.array([car_location.x,car_location.y,car_location.z, 1])
                    cords_x_y_z = ClientSideBoundingBoxes._vehicle_to_sensor(cords, car, camera_rgb)[:3, :]
                    cords_y_minus_z_x = np.concatenate([cords_x_y_z[1, :], -cords_x_y_z[2, :], cords_x_y_z[0, :]])
                    ###############location
                    bbox = np.transpose(np.dot(camera_coordinate(camera_rgb), cords_y_minus_z_x))
                    camera_bbox = (np.concatenate([bbox[:, 0] / bbox[:, 2], bbox[:, 1] / bbox[:, 2], bbox[:, 2]], axis=1))
                    # pdb.set_trace()
                    camera_bbox_e = camera_bbox[0]
                    # if camera_bbox_e[:,0]<0 or camera_bbox_e[:,1]<0 or camera_bbox_e[:,2]<0:
                    #     continue
                    if camera_bbox_e[:,2]<0:
                        continue
                    
                    #bboxe = camera_bbox
                    xmin,ymin,xmax,ymax=0,0,0,0
                    bboxe = ClientSideBoundingBoxes.get_bounding_boxes([car], camera_rgb)
                    if len(bboxe)==0:
                        continue
                    bboxe=bboxe[0]
                    bbox_in_image = (np.min(bboxe[:,0]), np.min(bboxe[:,1]), np.max(bboxe[:,0]), np.max(bboxe[:,1]))
                    bbox_crop = tuple(max(0, b) for b in bbox_in_image)
                    bbox_crop = (min(img_size[0], bbox_crop[0]),
                                min(img_size[1], bbox_crop[1]),
                                min(img_size[0], bbox_crop[2]),
                                min(img_size[1], bbox_crop[3]))
                    if bbox_crop[0] >= bbox_crop[2] or bbox_crop[1] >= bbox_crop[3]:
                        continue
                    #t_points = [(int(bboxe[i, 0]), int(bboxe[i, 1])) for i in range(8)]
                    # width_x=[int(bboxe[i, 0]) for i in range(8)]
                    # high_y=[int(bboxe[i, 1]) for i in range(8)]
                    # xmin,ymin,xmax,ymax=min(width_x),min(high_y),max(width_x),max(high_y)
                    xmin,ymin,xmax,ymax=bbox_crop
                    # x_cen=(xmin+xmax)/2
                    # y_cen=(ymin+ymax)/2
                    # if x_cen<0 or y_cen<0 or x_cen>VIEW_WIDTH or y_cen>VIEW_HEIGHT:
                    #     continue
                    car_type, truncated, occluded, alpha= 'Car', 0, 0,0
                    dh, dw,dl=extent.z*2,extent.y*2,extent.x*2
                    cords_y_minus_z_x=np.array(cords_y_minus_z_x)
                    ly, lz,lx=cords_y_minus_z_x[0][0],cords_y_minus_z_x[1][0],cords_y_minus_z_x[2][0]
                    lz=lz+dh
                    ry=(car.get_transform().rotation.yaw-camera_rgb.get_transform().rotation.yaw+90)*np.pi/180
                    check_box=False
                    ofs = 10
                    for one_box in car_2d_bbox:
                        xmi,ymi,xma,yma=one_box
                        if xmin>xmi-ofs and ymin>ymi-ofs and xmax<xma+ofs and ymax<yma+ofs:
                            check_box=True
                    if check_box or np.sqrt(ly**2+lx**2)<2:
                        continue

                    # bbox_crop = tuple(max(0, b) for b in [xmin,ymin,xmax,ymax])
                    # bbox_crop = (min(img_size[0], bbox_crop[0]),
                    #             min(img_size[1], bbox_crop[1]),
                    #             min(img_size[0], bbox_crop[2]),
                    #             min(img_size[1], bbox_crop[3]))
                    # Use segment image to determine whether the vehicle is occluded.
                    # See https://carla.readthedocs.io/en/0.9.11/ref_sensors/#semantic-segmentation-camera
                    # print('seg: ',semseg[int((ymin+ymax)/2),int((xmin+xmax)/2),0])
                    # print('x: ',int((ymin+ymax)/2),'y: ',int((xmin+xmax)/2))
                    if semseg[int((ymin+ymax)/2),int((xmin+xmax)/2),0] != 10:
                        continue

                    car_2d_bbox.append(bbox_crop)
                    
                    v.append(car)
                    if car not in all_vehicles_list:
                        all_vehicles_list.append(car)
                    if ry>np.pi:
                        ry-=np.pi
                    if ry<-np.pi:
                        ry+=np.pi
                    # pdb.set_trace()
                    txt="{} {} {} {} {} {} {} {} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {} {}\n".format(car_type, truncated, occluded, alpha, xmin, ymin, xmax, ymax, dh, dw,
                        dl,ly, lz, lx,  ry,car.id)
                    label_files.write(txt)
                label_files.close()
                #print(cam_type,cam_subset,k,len(v))

                #bounding_boxes = ClientSideBoundingBoxes.get_bounding_boxes(v, camera_rgb) 
                ######################################################file
                # pygame.image.save(display,'%s/image_1/%06d.png' % (out_path,k))       
                image.save_to_disk('{}/{}/image_2/{:0>6d}.png'.format (out_path,camera_rgb.sensor_name,k))        
            
            global_file_path = out_path + '/global_label_2'
            if not os.path.exists(global_file_path):
                os.makedirs(global_file_path)
            global_vehicle_file = open("{}/{:0>6d}.txt".format(global_file_path,k), "w")
            for vehicle in all_vehicles_list:
                extent = vehicle.bounding_box.extent
                car_type, truncated, occluded, alpha,xmin,ymin,xmax,ymax= 'Car', 0, 0,0,0,0,0,0
                dh, dw,dl=extent.z*2,extent.y*2,extent.x*2
                location  = vehicle.get_transform().location
                ly,lz,lx = location.x,location.y,location.z
                ry = vehicle.get_transform().rotation.yaw * np.pi / 180
                
                txt="{} {} {} {} {} {} {} {} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {} {}\n".format(car_type, truncated, occluded, alpha, xmin, ymin, xmax, ymax, dh, dw,
                            dl,ly, lz, lx,  ry_filter(ry),vehicle.id)
                global_vehicle_file.write(txt)
            global_vehicle_file.close()


    for camera_rgb in rgb_list:
        calib_files=open("{}/{}/calib/{:0>6d}.txt".format(out_path,camera_rgb.sensor_name,0), "w")
        K=camera_coordinate(camera_rgb)

        txt="P2: {} {} {} {} {} {} {} {} {}\n".format(  K[0][0],K[0][1],K[0][2],
                                                    K[1][0],K[1][1],K[1][2],
                                                    K[2][0],K[2][1],K[2][2])
        calib_files.write(txt)
        calib_files.close()

    print('destroying actors.')
    for actor in actor_list:
        actor.destroy()
    
    # world_snapshot = world.get_snapshot()
    # vehicles_actors = []
    # for vehicle in vehicles_actor:
    #     if world_snapshot.find(vehicle) is not None:
    #         vehicles_actors.append(vehicle)
    # for vehicle in vehicles_actor:
    #client.apply_batch([carla.command.DestroyActor(vehicle) for vehicle in vehicles_actors])

    #pygame.quit()
    return
コード例 #26
0
from carla import Location, Rotation, Transform

### Use case ###################################################################

client = carla.Client('localhost', 2000)

client.set_timeout(1000)

world = client.get_world()

blueprint_library = world.get_blueprint_library()
vehicle_blueprints = blueprint_library.filter('vehicle.mustang.*')
blueprint = random.choice(vehicle_blueprints)

transform = Transform(Location(50.0, 50.0, 2.0))
player_vehicle = world.spawn_actor(blueprint, transform)

vehicle_camera = carla.Camera('MyCameraDepth', type='Depth')
vehicle_camera.attach_to(player_vehicle, Transform(Location(z=60.0)))
vehicle_camera.listen(lambda image: image.save_to_disk())

static_camera = carla.Camera('SecurityCamera', type='SceneFinal')
static_camera.attach_to(world, Transform(Location(x=30.0), Rotation(yaw=90)))
static_camera.listen(lambda image: image.save_to_disk())

while True:
    control = carla.VehicleControl(throttle=0.6, reverse=True)
    player_vehicle.apply_control(control)

    time.sleep(1)
コード例 #27
0
    def Create_actors(self,world, blueprint_library): 
        ego_list = []
        npc_list = []
        obstacle_list = []
        sensor_list = []
        # ego车辆设置---------------------------------------------------------------
        ego_bp = blueprint_library.find(id='vehicle.lincoln.mkz2017')
        # 坐标建立
        ego_transform = Transform(Location(x=30, y=-4.350967, z=0.1), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        # 车辆从蓝图定义以及坐标生成
        ego = world.spawn_actor(ego_bp, ego_transform)
        ego_list.append(ego)
        print('created %s' % ego.type_id)

        # 视角设置------------------------------------------------------------------
        spectator = world.get_spectator()
        spec_transform = Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        spec_transform.location += carla.Location(x=-15,z=50)
        spec_transform.rotation = carla.Rotation(pitch=-90,yaw=0,roll=-0.000000)
        spectator.set_transform(spec_transform)

        # npc设置--------------------------------------------------------------------
        npc_transform = Transform(Location(x=30, y=-4.350967, z=0.1), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        for i in range(1):
            npc_transform.location += carla.Location(x=-11,y=6)
            npc_transform.rotation = carla.Rotation(pitch=0.348271,yaw=275, roll=-0.000000)
            npc_bp = blueprint_library.find(id='vehicle.lincoln.mkz2017')
            # print(npc_bp.get_attribute('color').recommended_values)
            npc_bp.set_attribute('color', '229,28,0')
            npc = world.try_spawn_actor(npc_bp, npc_transform)
            if npc is None:
                print('%s npc created failed' % i)
            else:
                npc_list.append(npc)
                print('created %s' % npc.type_id)

        # 障碍物设置------------------------------------------------------------------
        obsta_bp = blueprint_library.find(id='static.prop.streetbarrier')
        #障碍物1
        obstacle_transform1 =Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        obstacle_transform1.location += carla.Location(x=14,y=1.8)
        obstacle_transform1.rotation = carla.Rotation(pitch=0, yaw=0, roll=0.000000)
        for i in range(10):
            obstacle1 = world.try_spawn_actor(obsta_bp, obstacle_transform1)
            obstacle_transform1.location += carla.Location(x=-2.5,y=-0.04)
            obstacle_list.append(obstacle1)
        #障碍物2
        obstacle_transform2 =Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        obstacle_transform2.location += carla.Location(x=-8.5,y=1.82)
        obstacle_transform2.rotation = carla.Rotation(pitch=0, yaw=275, roll=0.000000)
        for i in range(4):
            obstacle2 = world.try_spawn_actor(obsta_bp, obstacle_transform2)
            obstacle_transform2.location += carla.Location(x=-0.1,y=2.5)
            obstacle_list.append(obstacle2)
        #障碍物3
        obstacle_transform3 =Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        obstacle_transform3.location += carla.Location(x=13,y=-1.8)
        obstacle_transform3.rotation = carla.Rotation(pitch=0, yaw=0, roll=0.000000)
        for i in range(9):
            obstacle3 = world.try_spawn_actor(obsta_bp, obstacle_transform3)
            obstacle_transform3.location += carla.Location(x=-2.5,y=-0.1)
            obstacle_list.append(obstacle3)
        #障碍物4
        obstacle_transform4 =Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        obstacle_transform4.location += carla.Location(x=-24,y=-52)
        obstacle_transform4.rotation = carla.Rotation(pitch=0, yaw=270, roll=0.000000)
        for i in range(15):
            obstacle4 = world.try_spawn_actor(obsta_bp, obstacle_transform4)
            obstacle_transform4.location += carla.Location(x=-0.05,y=2.5)
            obstacle_list.append(obstacle4)
        #障碍物5
        obstacle_transform5 =Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        obstacle_transform5.location += carla.Location(x=-20.5,y=-52)
        obstacle_transform5.rotation = carla.Rotation(pitch=0, yaw=270, roll=0.000000)
        for i in range(13):
            obstacle5 = world.try_spawn_actor(obsta_bp, obstacle_transform5)
            obstacle_transform5.location += carla.Location(x=-0.05,y=2.5)
            obstacle_list.append(obstacle5)
        #障碍物6
        obstacle_transform6 =Transform(Location(x=30, y=-4.350967, z=0), 
                    Rotation(pitch=-0.348271, yaw=180, roll=-0.000000))
        obstacle_transform6.location += carla.Location(x=-20,y=-21)
        obstacle_transform6.rotation = carla.Rotation(pitch=0, yaw=45, roll=0.000000)
        for i in range(8):
            obstacle6 = world.try_spawn_actor(obsta_bp, obstacle_transform6)
            obstacle_transform6.location += carla.Location(x=1.7,y=2.4)
            obstacle_list.append(obstacle6)
        # 传感器设置-------------------------------------------------------------------
        ego_collision = SS.CollisionSensor(ego)
        npc_collision = SS.CollisionSensor(npc)
        ego_invasion = SS.LaneInvasionSensor(ego)
        npc_invasion = SS.LaneInvasionSensor(npc)
        sensor_list.extend([[ego_collision,ego_invasion],[npc_collision,npc_invasion]])

        return ego_list,npc_list,obstacle_list,sensor_list
コード例 #28
0
    def Create_actors(self, world, blueprint_library):
        ego_list = []
        npc_list = []
        obstacle_list = []
        sensor_list = []
        # ego车辆设置---------------------------------------------------------------
        ego_bp = blueprint_library.find(id='vehicle.lincoln.mkz2017')
        # 坐标建立
        ego_transform = Transform(Location(x=9, y=-110.350967, z=0.1),
                                  Rotation(pitch=0, yaw=-90, roll=-0.000000))
        # 车辆从蓝图定义以及坐标生成
        ego = world.spawn_actor(ego_bp, ego_transform)
        ego_list.append(ego)
        print('created %s' % ego.type_id)

        # 视角设置------------------------------------------------------------------
        spectator = world.get_spectator()
        # spec_transform = ego.get_transform()
        spec_transform = Transform(Location(x=9, y=-115.350967, z=0),
                                   Rotation(pitch=0, yaw=180, roll=-0.000000))
        spec_transform.location += carla.Location(x=-5, z=60)
        spec_transform.rotation = carla.Rotation(pitch=-90,
                                                 yaw=1.9,
                                                 roll=-0.000000)
        spectator.set_transform(spec_transform)

        # npc设置--------------------------------------------------------------------
        npc_transform = Transform(Location(x=9, y=-110.350967, z=0.1),
                                  Rotation(pitch=0, yaw=-90, roll=-0.000000))
        for i in range(1):
            npc_transform.location += carla.Location(x=-18, y=-24)
            npc_transform.rotation = carla.Rotation(pitch=0,
                                                    yaw=0,
                                                    roll=-0.000000)
            npc_bp = blueprint_library.find(id='vehicle.lincoln.mkz2017')
            # print(npc_bp.get_attribute('color').recommended_values)
            npc_bp.set_attribute('color', '229,28,0')
            npc = world.try_spawn_actor(npc_bp, npc_transform)
            if npc is None:
                print('%s npc created failed' % i)
            else:
                npc_list.append(npc)
                print('created %s' % npc.type_id)

        # 障碍物设置------------------------------------------------------------------
        obsta_bp = blueprint_library.find(id='static.prop.streetbarrier')
        # 障碍物1
        obstacle_transform1 = Transform(
            Location(x=9, y=-110.350967, z=0),
            Rotation(pitch=0, yaw=-90, roll=-0.000000))
        obstacle_transform1.location += carla.Location(x=50, y=-27, z=3)
        obstacle_transform1.rotation = carla.Rotation(pitch=0,
                                                      yaw=0,
                                                      roll=0.000000)
        for i in range(30):
            obstacle1 = world.try_spawn_actor(obsta_bp, obstacle_transform1)
            obstacle_transform1.location += carla.Location(x=-2.5,
                                                           y=-0.05,
                                                           z=-0.12)
            obstacle_list.append(obstacle1)
        # 障碍物2
        # obstacle_transform2 = Transform(Location(x=9, y=-110.350967,z=0),
        #             Rotation(pitch=0, yaw=-90, roll=-0.000000))
        # obstacle_transform2.location += carla.Location(x=-2.8,y=-18.5)
        # obstacle_transform2.rotation = carla.Rotation(pitch=0, yaw=0, roll=0.000000)
        # for i in range(7):
        #     obstacle2 = world.try_spawn_actor(obsta_bp, obstacle_transform2)
        #     obstacle_transform2.location += carla.Location(x=-2.5)
        #     obstacle_list.append(obstacle2)
        # # 障碍物3
        # obstacle_transform3 = Transform(Location(x=9, y=-110.350967,z=0),
        #             Rotation(pitch=0, yaw=-90, roll=-0.000000))
        # obstacle_transform3.location += carla.Location(x=-1.65,y=-17.5)
        # obstacle_transform3.rotation = carla.Rotation(pitch=0, yaw=90, roll=0.000000)
        # for i in range(10):
        #     obstacle3 = world.try_spawn_actor(obsta_bp, obstacle_transform3)
        #     obstacle_transform3.location += carla.Location(x=0.006,y=2.5)
        #     obstacle_list.append(obstacle3)
        # # 障碍物4
        # obstacle_transform4 = Transform(Location(x=9, y=-110.350967,z=0),
        #             Rotation(pitch=0, yaw=-90, roll=-0.000000))
        # obstacle_transform4.location += carla.Location(x=2.45,y=-15)
        # obstacle_transform4.rotation = carla.Rotation(pitch=0, yaw=90, roll=0.000000)
        # for i in range(10):
        #     obstacle4 = world.try_spawn_actor(obsta_bp, obstacle_transform4)
        #     obstacle_transform4.location += carla.Location(y=2.5)
        #     obstacle_list.append(obstacle4)

        # 传感器设置-------------------------------------------------------------------
        ego_collision = SS.CollisionSensor(ego)
        npc_collision = SS.CollisionSensor(npc)
        ego_invasion = SS.LaneInvasionSensor(ego)
        npc_invasion = SS.LaneInvasionSensor(npc)
        sensor_list.extend([[ego_collision, ego_invasion],
                            [npc_collision, npc_invasion]])

        return ego_list, npc_list, obstacle_list, sensor_list
コード例 #29
0
    def restart(self):
        # Keep same camera config if the camera manager exists.
        cam_index = self.camera_manager.index if self.camera_manager is not None else 0
        cam_pos_index = self.camera_manager.transform_index if self.camera_manager is not None else 0
        # Get a random blueprint.
        # ******I have made this random.choice just have one choice --> vehicle.bmw.grandtourer
        blueprint = random.choice(self.world.get_blueprint_library().filter(
            self._actor_filter))
        # print("blue print")
        # print(self.world.get_blueprint_library().filter(self._actor_filter))
        blueprint.set_attribute('role_name', 'hero')
        if blueprint.has_attribute('color'):
            color = random.choice(
                blueprint.get_attribute('color').recommended_values)
            # print("color")
            # print(blueprint.get_attribute('color').recommended_values)
            # ****** I have set the blueprint being white as '255,255,255'
            blueprint.set_attribute('color', '255,255,255')
        batch = []
        blueprint2 = random.choice(self.world.get_blueprint_library().filter(
            self._actor_filter))
        blueprint2.set_attribute('role_name', 'hero2')
        if blueprint2.has_attribute('color'):
            blueprint2.set_attribute('color', '0,0,0')
        # batch.append(SpawnActor(blueprint, transform))

        # Spawn the player.

        #     ******************* change positions ****************************************
        while self.player1 is None:
            # spawn_points = self.map.get_spawn_points()
            # print("length of sapwn_point is %d" % len(spawn_points) + ",just choose one")  # 257 just choose one
            x_rand = random.randint(18000, 23000)
            x_rand_v2 = random.randint(x_rand + 1000, 25000)
            x_rand = x_rand / 100.0
            x_rand_v2 = x_rand_v2 / 100.0
            y_rand = random.randint(12855, 13455)
            y_rand = y_rand / 100.0
            x_speed_randon_v2 = random.randint(100, 3000)
            if x_speed_randon_v2 - 1000 > 0:
                x_speed_player = x_speed_randon_v2 - 100

            else:
                x_speed_player = 0
            x_speed_player = x_speed_player / 100

            x_speed_randon_v2 = x_speed_randon_v2 / 100
            spawn_point1 = Transform(
                Location(x=x_rand, y=y_rand, z=1.320625),
                Rotation(pitch=0.000000, yaw=179.999756, roll=0.000000))
            # ********************************* end *****************************************
            self.player1 = self.world.try_spawn_actor(blueprint, spawn_point1)
            spawn_point2 = Transform(
                Location(x=x_rand_v2, y=y_rand, z=1.320625),
                Rotation(pitch=0.000000, yaw=179.999756, roll=0.000000))
            if self.vehicle2 is None:
                # print("*****************")
                self.vehicle2 = self.world.try_spawn_actor(
                    blueprint2, spawn_point2)
                self.vehicle2.set_velocity(
                    carla.Vector3D(x=-x_speed_randon_v2, y=0.00000,
                                   z=0.000000))
                self.player1.set_velocity(
                    carla.Vector3D(x=-x_speed_player, y=0.00000, z=0.00000))

        # Set up the sensors.
        self.collision_sensor = CollisionSensor(self.player1, self.hud)
        self.lane_invasion_sensor = LaneInvasionSensor(self.player1, self.hud)
        self.gnss_sensor = GnssSensor(self.player1)
        self.camera_manager = CameraManager(self.player1, self.hud)
        self.camera_manager.transform_index = cam_pos_index
        self.camera_manager.set_sensor(cam_index, notify=False)
        actor_type = get_actor_display_name(self.player1)
        self.hud.notification(actor_type)
コード例 #30
0
ファイル: utils.py プロジェクト: wnklmx/pylot
def get_top_down_transform(transform, top_down_camera_altitude):
    # Calculation relies on the fact that the camera's FOV is 90.
    top_down_location = (transform.location +
                         Location(0, 0, top_down_camera_altitude))
    return Transform(top_down_location, Rotation(-90, 0, 0))