def map_dynamic_actor(actor: carla.Actor,
world_map: carla.Map) -> DynamicActor:
location: carla.Location = actor.get_location()
gnss: carla.GeoLocation = world_map.transform_to_geolocation(location)
velocity: carla.Vector3D = actor.get_velocity()
acceleration: carla.Vector3D = actor.get_acceleration()
color: str = str(
actor.attributes['color']) if 'color' in actor.attributes else None
extent: carla.Vector3D = actor.bounding_box.extent
transform: carla.Transform = carla.Transform(
rotation=actor.get_transform().rotation)
transformed_extent: Tuple[carla.Location, carla.Location, carla.Location,
carla.Location] = (
transform.transform(
carla.Location(+extent.x, +extent.y, 0)),
transform.transform(
carla.Location(+extent.x, -extent.y, 0)),
transform.transform(
carla.Location(-extent.x, -extent.y, 0)),
transform.transform(
carla.Location(-extent.x, +extent.y, 0)),
)
bbox: Tuple[Point2D, Point2D, Point2D, Point2D] = cast(
Tuple[Point2D, Point2D, Point2D, Point2D],
tuple(
map(
lambda t: geoloc2point2d(
world_map.transform_to_geolocation(
carla.Vector3D(location.x + t.x, location.y + t.y,
location.z))), transformed_extent)))
return DynamicActor(
id=actor.id,
type=UncertainProperty(1., resolve_carla_type(actor.type_id)),
type_id=actor.type_id,
location=UncertainProperty(1.,
Point3D(location.x, location.y,
location.z)),
gnss=UncertainProperty(
1., Point3D(gnss.latitude, gnss.longitude, gnss.altitude)),
dynamics=ActorDynamics(velocity=UncertainProperty(
1., Point3D(velocity.x, velocity.y, velocity.z)),
acceleration=UncertainProperty(
1.,
Point3D(acceleration.x, acceleration.y,
acceleration.z))),
props=ActorProperties(color=UncertainProperty(1., color),
extent=UncertainProperty(
1., Point3D(extent.x, extent.y, extent.z)),
bbox=UncertainProperty(1., bbox)))
def compute_all_paths_for_actor(
vehicle: carla.Actor,
dist_between_waypoints: float,
path_length: int = 10,
lane_type: carla.LaneType = carla.LaneType.Driving,
verbose: bool = False):
world = vehicle.get_world()
location = vehicle.get_location()
paths = compute_all_paths_from_location(location, world,
dist_between_waypoints,
path_length, lane_type, verbose)
return paths
def produce(self, agent_vehicle: carla.Actor) -> BirdView:
all_actors = actors.query_all(world=self._world)
segregated_actors = actors.segregate_by_type(actors=all_actors)
agent_vehicle_loc = agent_vehicle.get_location()
# Reusing already generated static masks for whole map
self.masks_generator.disable_local_rendering_mode()
agent_global_px_pos = self.masks_generator.location_to_pixel(
agent_vehicle_loc)
cropping_rect = CroppingRect(
x=int(agent_global_px_pos.x - self.rendering_area.width / 2),
y=int(agent_global_px_pos.y - self.rendering_area.height / 2),
width=self.rendering_area.width,
height=self.rendering_area.height,
)
masks = np.zeros(
shape=(
len(BirdViewMasks),
self.rendering_area.height,
self.rendering_area.width,
),
dtype=np.uint8,
)
masks[BirdViewMasks.ROAD.value] = self.full_road_cache[
cropping_rect.vslice, cropping_rect.hslice]
masks[BirdViewMasks.LANES.value] = self.full_lanes_cache[
cropping_rect.vslice, cropping_rect.hslice]
masks[BirdViewMasks.CENTERLINES.value] = self.full_centerlines_cache[
cropping_rect.vslice, cropping_rect.hslice]
masks[BirdViewMasks.BUILDINGS.value] = self.full_buildings_cache[
cropping_rect.vslice, cropping_rect.hslice]
# Dynamic masks
rendering_window = RenderingWindow(origin=agent_vehicle_loc,
area=self.rendering_area)
self.masks_generator.enable_local_rendering_mode(rendering_window)
masks = self._render_actors_masks(agent_vehicle, segregated_actors,
masks)
cropped_masks = self.apply_agent_following_transformation_to_masks(
agent_vehicle, masks)
ordered_indices = [
mask.value for mask in BirdViewMasks.bottom_to_top()
]
return cropped_masks[:, :, ordered_indices]
